@commercetools-frontend/experimental-components 0.0.2 → 0.0.3

package/src/utils/prices/prices.spec.js

@@ -1,265 +0,0 @@
-import { PRECISION_TYPES } from '../constants';
-import {
-  getPriceChannelName,
-  getDiscountValue,
-  getSelectedPrice,
-  getNetUnitPrice,
-  getMinimumPricesByCurrencyCode,
-} from './prices';
-
-describe('getPriceChannelName', () => {
-  describe('when there is no channel on price', () => {
-    describe.each([{}, { channel: {} }])('with price: %j', (price) => {
-      it('should return null', () => {
-        expect(getPriceChannelName(price)).toBe(null);
-      });
-    });
-  });
-
-  describe('when price has a channel with a name', () => {
-    it('should return name', () => {
-      const price = { channel: { name: 'channel-1' } };
-      expect(getPriceChannelName(price)).toBe('channel-1');
-    });
-  });
-
-  describe('when price has a channel with no name but a key', () => {
-    it('should return the key', () => {
-      const price = { channel: { key: 'channel-1-key' } };
-      expect(getPriceChannelName(price)).toBe('channel-1-key');
-    });
-  });
-});
-
-describe('getDiscountValue', () => {
-  it('should have property of fractionalAmount when price is precise and discount is cent', () => {
-    const price = {
-      value: {
-        currencyCode: 'EUR',
-        preciseAmount: 1000000,
-        fractionDigits: 5,
-        type: PRECISION_TYPES.highPrecision,
-      },
-      discounted: {
-        value: {
-          currencyCode: 'EUR',
-          centAmount: 900,
-          fractionDigits: 2,
-          type: PRECISION_TYPES.centPrecision,
-        },
-      },
-    };
-
-    expect(getDiscountValue(price)).toHaveProperty('fractionedAmount', 1);
-  });
-
-  it('should return the discount value between price and discounted', () => {
-    const price = {
-      value: {
-        currencyCode: 'EUR',
-        centAmount: 1000,
-      },
-      discounted: {
-        value: {
-          currencyCode: 'EUR',
-          centAmount: 900,
-        },
-      },
-    };
-    expect(getDiscountValue(price)).toEqual({
-      currencyCode: 'EUR',
-      centAmount: 100,
-    });
-  });
-
-  it('should return 0 in money format when no discount is set', () => {
-    const price = {
-      value: {
-        currencyCode: 'EUR',
-        centAmount: 1000,
-      },
-    };
-    expect(getDiscountValue(price)).toEqual({
-      currencyCode: 'EUR',
-      centAmount: 0,
-    });
-  });
-});
-
-describe('getSelectedPrice', () => {
-  it('should return the discounted price', () => {
-    const price = {
-      value: {
-        currencyCode: 'EUR',
-        centAmount: 1000,
-      },
-      discounted: {
-        value: {
-          currencyCode: 'EUR',
-          centAmount: 900,
-        },
-      },
-    };
-    expect(getSelectedPrice(price)).toEqual({
-      value: {
-        currencyCode: 'EUR',
-        centAmount: 900,
-      },
-    });
-  });
-
-  it('should return the price in money format when no discount is set', () => {
-    const price = {
-      value: {
-        currencyCode: 'EUR',
-        centAmount: 1000,
-      },
-    };
-    expect(getSelectedPrice(price)).toEqual({
-      value: {
-        currencyCode: 'EUR',
-        centAmount: 1000,
-      },
-    });
-  });
-});
-
-describe('getNetUnitPrice', () => {
-  let price;
-  describe('with taxRate', () => {
-    describe('if taxRate is includedInPrice', () => {
-      describe('if amount should be rounded', () => {
-        beforeEach(() => {
-          price = getNetUnitPrice({
-            lineItem: {
-              taxRate: {
-                amount: 0.19,
-                includedInPrice: true,
-              },
-              // See https://jira.commercetools.com/browse/MCD-742
-              price: { value: { currencyCode: 'EUR', centAmount: 19499 } },
-            },
-            shouldRoundAmount: true,
-          });
-        });
-        it('should return rounded price value', () => {
-          expect(price).toEqual({ currencyCode: 'EUR', centAmount: 16386 });
-        });
-      });
-      describe('if amount should not be rounded', () => {
-        beforeEach(() => {
-          price = getNetUnitPrice({
-            lineItem: {
-              taxRate: {
-                amount: 0.19,
-                includedInPrice: true,
-              },
-              // See https://jira.commercetools.com/browse/MCD-742
-              price: { value: { currencyCode: 'EUR', centAmount: 19499 } },
-            },
-            shouldRoundAmount: false,
-          });
-        });
-        it('should return raw price value', () => {
-          expect(price).toEqual({
-            currencyCode: 'EUR',
-            centAmount: 16385.714285714286,
-          });
-        });
-      });
-    });
-    describe('if taxRate is not includedInPrice', () => {
-      beforeEach(() => {
-        price = getNetUnitPrice({
-          lineItem: {
-            taxRate: { amount: 0.19, includedInPrice: false },
-            price: { value: { currencyCode: 'EUR', centAmount: 1000 } },
-          },
-          shouldRoundAmount: true,
-        });
-      });
-      it('should return price value', () => {
-        expect(price).toEqual({ currencyCode: 'EUR', centAmount: 1000 });
-      });
-    });
-  });
-  describe('without taxRate', () => {
-    beforeEach(() => {
-      price = getNetUnitPrice({
-        lineItem: {
-          price: { value: { currencyCode: 'EUR', centAmount: 1000 } },
-        },
-        shouldRoundAmount: true,
-      });
-    });
-    it('should return price value', () => {
-      expect(price).toEqual({ currencyCode: 'EUR', centAmount: 1000 });
-    });
-  });
-});
-
-describe('getMinimumPricesByCurrencyCode', () => {
-  let prices;
-  describe('with empty prices', () => {
-    beforeEach(() => {
-      prices = [];
-    });
-    it('should return empty array', () => {
-      expect(getMinimumPricesByCurrencyCode(prices)).toHaveLength(0);
-    });
-  });
-  describe('with prices', () => {
-    beforeEach(() => {
-      prices = [
-        {
-          value: {
-            currencyCode: 'EUR',
-            centAmount: 1000,
-          },
-        },
-        {
-          value: {
-            currencyCode: 'EUR',
-            centAmount: 9000,
-          },
-        },
-        {
-          value: {
-            currencyCode: 'EUR',
-            centAmount: 10000,
-          },
-        },
-        {
-          value: {
-            currencyCode: 'USD',
-            centAmount: 1000,
-          },
-        },
-        {
-          value: {
-            currencyCode: 'USD',
-            centAmount: 9000,
-          },
-        },
-        {
-          value: {
-            currencyCode: 'USD',
-            centAmount: 10000,
-          },
-        },
-      ];
-    });
-    it('should return only minimum prices for each currency', () => {
-      expect(getMinimumPricesByCurrencyCode(prices)).toEqual([
-        {
-          currencyCode: 'EUR',
-          centAmount: 1000,
-        },
-        {
-          currencyCode: 'USD',
-          centAmount: 1000,
-        },
-      ]);
-    });
-  });
-});

package/src/utils/product-selections/convert-product-selection-from-graphql.js

@@ -1,80 +0,0 @@
-import {
-  applyTransformedLocalizedFields,
-  transformLocalizedFieldToLocalizedString,
-} from '@commercetools-frontend/l10n';
-
-const transformCustomFieldFromGraphQLResponse = (resource) => ({
-  type: {
-    typeId: 'type',
-    id: resource.custom.type.id,
-    obj: {
-      key: resource.custom.type.key,
-      name: transformLocalizedFieldToLocalizedString(
-        resource.custom.type.nameAllLocales
-      ),
-      fieldDefinitions: resource.custom.type.fieldDefinitions.map(
-        (fieldDefinition) => ({
-          name: fieldDefinition.name,
-          required: fieldDefinition.required,
-          type: do {
-            if (fieldDefinition.type?.elementType?.name === 'LocalizedEnum')
-              ({
-                ...fieldDefinition.type,
-                elementType: {
-                  ...fieldDefinition.type.elementType,
-                  values: fieldDefinition.type.elementType.values.map(
-                    (value) => ({
-                      key: value.key,
-                      label: transformLocalizedFieldToLocalizedString(
-                        value.labelAllLocales
-                      ),
-                    })
-                  ),
-                },
-              });
-            else if (fieldDefinition.type?.name === 'LocalizedEnum')
-              ({
-                ...fieldDefinition.type,
-                values: fieldDefinition.type.values.map((value) => ({
-                  key: value.key,
-                  label: transformLocalizedFieldToLocalizedString(
-                    value.labelAllLocales
-                  ),
-                })),
-              });
-            else fieldDefinition.type;
-          },
-          label: transformLocalizedFieldToLocalizedString(
-            fieldDefinition.labelAllLocales
-          ),
-        })
-      ),
-    },
-  },
-  fields: resource.custom.customFieldsRaw.reduce(
-    (fields, customField) => ({
-      ...fields,
-      [customField.name]: customField.value,
-    }),
-    {}
-  ),
-});
-
-// eslint-disable-next-line import/prefer-default-export
-export const convertProductSelectionFromGraphQl = (productSelection) => {
-  // the reason to default to null is that the consumer of the hook should expect consistent value.
-  // Incase the product selection is not missing or if the current project dose not yet have access to the feature,
-  // in either case we return null
-  if (!productSelection) return null;
-  return {
-    ...applyTransformedLocalizedFields(productSelection, [
-      {
-        from: 'nameAllLocales',
-        to: 'name',
-      },
-    ]),
-    custom: productSelection?.custom
-      ? transformCustomFieldFromGraphQLResponse(productSelection)
-      : null,
-  };
-};

package/src/utils/product-selections/index.js

@@ -1 +0,0 @@
-export * from './convert-product-selection-from-graphql';

package/src/utils/product-types/index.js

@@ -1 +0,0 @@
-export * from './product-types';

package/src/utils/product-types/product-types.js

@@ -1,122 +0,0 @@
-import sortBy from 'lodash.sortby';
-import uniqBy from 'lodash.uniqby';
-import { defaultMemoize } from 'reselect';
-
-const getIsAttributeOfTypeEnum = (attributeType) =>
-  attributeType.name === 'enum' ||
-  attributeType.name === 'lenum' ||
-  (attributeType.name === 'set' &&
-    (attributeType.elementType.name === 'enum' ||
-      attributeType.elementType.name === 'lenum'));
-
-export function mergeEnumValues(attribute, attributeToMergeValuesWith) {
-  const enumValues =
-    attribute.type.name === 'set'
-      ? attribute.type.elementType.values
-      : attribute.type.values;
-
-  const enumValuesToMergeWith =
-    attributeToMergeValuesWith.type.name === 'set'
-      ? attributeToMergeValuesWith.type.elementType.values
-      : attributeToMergeValuesWith.type.values;
-
-  return uniqBy([...enumValues, ...enumValuesToMergeWith], 'key');
-}
-
-export function updateEnumValuesOnAttribute(attribute, enumValues) {
-  const isAttributeOfTypeSet = attribute.type.name === 'set';
-  const type = isAttributeOfTypeSet
-    ? {
-        ...attribute.type,
-        elementType: {
-          ...attribute.type.elementType,
-          values: enumValues,
-        },
-      }
-    : {
-        ...attribute.type,
-        values: enumValues,
-      };
-
-  return {
-    ...attribute,
-    type,
-  };
-}
-
-export const getAllValidAttributes = defaultMemoize((productTypes) => {
-  const allAttributes = {};
-  productTypes.forEach((productType) => {
-    productType.attributes.forEach((attribute) => {
-      if (attribute.isSearchable && attribute.type.name !== 'nested') {
-        const attributeOfSameName = allAttributes[attribute.name];
-        // Attributes that are of the same name and are of type enum or set enum,
-        // should have their enum values merged, since we have cases where there
-        // are 2 or more productTypes having attributes with the same name
-        // and are missing values.
-        //
-        // example input:
-        // productTypes = [
-        //   {
-        //     attributes: [
-        //       {
-        //         name: 'enum-of-same-name',
-        //         type: {
-        //           name: 'enum',
-        //           values: [
-        //             { key: enum-1, label: enum-1 },
-        //             { key: enum-3, label: enum-3 },
-        //             { key: enum-5, label: enum-5 },
-        //           ],
-        //         },
-        //       },
-        //     ],
-        //   },
-        //   {
-        //     attributes: [
-        //       {
-        //         name: 'enum-of-same-name',
-        //         type: {
-        //           name: 'enum',
-        //           values: [
-        //             { key: enum-2, label: enum-2 },
-        //             { key: enum-4, label: enum-4 },
-        //           ],
-        //         },
-        //       },
-        //     ],
-        //   },
-        // ]
-        //
-        // expected output:
-        // attributes = [
-        //   {
-        //     name: 'enum-of-same-name',
-        //     type: {
-        //       name: 'enum',
-        //       values: [
-        //         { key: enum-1, label: enum-1 },
-        //         { key: enum-2, label: enum-2 },
-        //         { key: enum-3, label: enum-3 },
-        //         { key: enum-4, label: enum-4 },
-        //         { key: enum-5, label: enum-5 },
-        //       ],
-        //     },
-        //   },
-        // ]
-        if (attributeOfSameName && getIsAttributeOfTypeEnum(attribute.type)) {
-          const mergedEnumValues = mergeEnumValues(
-            attributeOfSameName,
-            attribute
-          );
-          allAttributes[attribute.name] = updateEnumValuesOnAttribute(
-            attributeOfSameName,
-            sortBy(mergedEnumValues, 'key')
-          );
-        } else if (!attributeOfSameName)
-          allAttributes[attribute.name] = attribute;
-      }
-    });
-  });
-  return Object.values(allAttributes);
-});