@commercetools-frontend/experimental-components 0.0.2

package/src/utils/graphql/index.js

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

package/src/utils/has-error-code/has-error-code.js

@@ -0,0 +1,15 @@
+/**
+ * Inspects API errors for error codes
+ *
+ * @param {?Array<{extensions: {code: string}}>} unmappedApiErrors
+ * @param {string} errorCode
+ * @returns {boolean}
+ */
+const hasErrorCode = (unmappedApiErrors, errorCode) => {
+  return (
+    Array.isArray(unmappedApiErrors) &&
+    unmappedApiErrors.some((error) => error.extensions?.code === errorCode)
+  );
+};
+
+export default hasErrorCode;

package/src/utils/has-error-code/has-error-code.spec.js

@@ -0,0 +1,56 @@
+import { ERROR_CODES } from '../constants';
+import hasErrorCode from './has-error-code';
+
+const InvalidInput = ERROR_CODES.invalidInput;
+
+describe('has invalid input', () => {
+  it('returns true if invalid input code exists', () => {
+    const errors = [
+      {
+        extensions: {
+          code: InvalidInput,
+        },
+      },
+    ];
+
+    expect(hasErrorCode(errors, InvalidInput)).toBeTruthy();
+  });
+
+  it('returns false if the error code is not InvalidInput', () => {
+    const errors = [
+      {
+        extensions: {
+          code: 'FooBarError',
+        },
+      },
+    ];
+
+    expect(hasErrorCode(errors, InvalidInput)).toBeFalsy();
+  });
+
+  it('returns false if the error code does not exist', () => {
+    const errors = [{}];
+
+    expect(hasErrorCode(errors, InvalidInput)).toBeFalsy();
+  });
+
+  it('returns false if the errors are not an array', () => {
+    const errors = {};
+
+    expect(hasErrorCode(errors, InvalidInput)).toBeFalsy();
+  });
+
+  it('returns false if the array is empty', () => {
+    const errors = [];
+
+    expect(hasErrorCode(errors, InvalidInput)).toBeFalsy();
+  });
+
+  it('returns false if the errors are nullish', () => {
+    const errorA = null;
+    const errorB = undefined;
+
+    expect(hasErrorCode(errorA, InvalidInput)).toBeFalsy();
+    expect(hasErrorCode(errorB, InvalidInput)).toBeFalsy();
+  });
+});

package/src/utils/has-error-code/has-invalid-input-error.js

@@ -0,0 +1,7 @@
+import { ERROR_CODES } from '../constants';
+import hasErrorCode from './has-error-code';
+
+const hasInvalidInputError = (errors) =>
+  hasErrorCode(errors, ERROR_CODES.invalidInput);
+
+export default hasInvalidInputError;

package/src/utils/has-error-code/has-semantic-error.js

@@ -0,0 +1,7 @@
+import { ERROR_CODES } from '../constants';
+import hasErrorCode from './has-error-code';
+
+const hasSemanticError = (errors) =>
+  hasErrorCode(errors, ERROR_CODES.semanticError);
+
+export default hasSemanticError;

package/src/utils/has-error-code/has-semantic-error.spec.js

@@ -0,0 +1,56 @@
+import { ERROR_CODES } from '../constants';
+import hasErrorCode from './has-error-code';
+
+const SemanticError = ERROR_CODES.semanticError;
+
+describe('has semantic error', () => {
+  it('returns true if semantic error code exists', () => {
+    const errors = [
+      {
+        extensions: {
+          code: SemanticError,
+        },
+      },
+    ];
+
+    expect(hasErrorCode(errors, SemanticError)).toBeTruthy();
+  });
+
+  it('returns false if the error code is not SemanticError', () => {
+    const errors = [
+      {
+        extensions: {
+          code: 'FooBarError',
+        },
+      },
+    ];
+
+    expect(hasErrorCode(errors, SemanticError)).toBeFalsy();
+  });
+
+  it('returns false if the error code does not exist', () => {
+    const errors = [{}];
+
+    expect(hasErrorCode(errors, SemanticError)).toBeFalsy();
+  });
+
+  it('returns false if the errors are not an array', () => {
+    const errors = {};
+
+    expect(hasErrorCode(errors, SemanticError)).toBeFalsy();
+  });
+
+  it('returns false if the array is empty', () => {
+    const errors = [];
+
+    expect(hasErrorCode(errors, SemanticError)).toBeFalsy();
+  });
+
+  it('returns false if the errors are nullish', () => {
+    const errorA = null;
+    const errorB = undefined;
+
+    expect(hasErrorCode(errorA, SemanticError)).toBeFalsy();
+    expect(hasErrorCode(errorB, SemanticError)).toBeFalsy();
+  });
+});

package/src/utils/has-error-code/index.js

@@ -0,0 +1,3 @@
+export { default } from './has-error-code';
+export { default as hasSemanticError } from './has-semantic-error';
+export { default as hasInvalidInputError } from './has-invalid-input-error';

package/src/utils/is-uuid/index.js

@@ -0,0 +1 @@
+export { default } from './is-uuid';

package/src/utils/is-uuid/is-uuid.js

@@ -0,0 +1,6 @@
+const isUUID = (string) =>
+  /^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$/.test(
+    string
+  );
+
+export default isUUID;

package/src/utils/is-uuid/is-uuid.spec.js

@@ -0,0 +1,25 @@
+import isUUID from './is-uuid';
+
+describe('isUUID', () => {
+  describe.each`
+    maybeValidUUID                             | isValidUUID
+    ${'0e39c0ca-d736-49aa-a0f7-5cc4af6d9c48'}  | ${true}
+    ${'ca0c0741-a115-43f5-956e-beb51517eb89'}  | ${true}
+    ${'b3129e44-1dd1-437b-985a-554f7b92bc56'}  | ${true}
+    ${'33b86b40-c9a7-4e21-8916-2cf68ff77d8e'}  | ${true}
+    ${'0e39c0ca-d736-49aa-a0f7-5cc4af6d9c48a'} | ${false}
+    ${'aca0c0741-a115-43f5-956e-beb51517eb89'} | ${false}
+    ${'b3129e44-21dd1-437b-985a-554f7b92bc56'} | ${false}
+    ${'b3129e44-21dd1-437b-985a'}              | ${false}
+    ${'John doe'}                              | ${false}
+    ${''}                                      | ${false}
+    ${undefined}                               | ${false}
+    ${null}                                    | ${false}
+  `('when called with $maybeValidUUID', ({ maybeValidUUID, isValidUUID }) => {
+    it(`should indicate that it's a ${
+      isValidUUID ? 'valid' : 'invalid'
+    } UUID`, () => {
+      expect(isUUID(maybeValidUUID)).toBe(isValidUUID);
+    });
+  });
+});

package/src/utils/minusify/index.js

@@ -0,0 +1 @@
+export { default } from './minusify';

package/src/utils/minusify/minusify.js

@@ -0,0 +1,4 @@
+export default function minusify(value) {
+  const minus = '-';
+  return minus.concat(value);
+}

package/src/utils/minusify/minusify.spec.js

@@ -0,0 +1,9 @@
+import minusify from './minusify';
+
+describe('returning correct values', () => {
+  const value = 'x';
+  it('should return the value with hifen in front', () => {
+    const minusfiedValue = minusify(value);
+    expect(minusfiedValue).toBe('-x');
+  });
+});

package/src/utils/numbers/index.js

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

package/src/utils/numbers/numbers.js

@@ -0,0 +1,32 @@
+const formats = {
+  en: [',', '.'],
+  de: ['.', ','],
+  it: ['.', ','],
+  ru: [' ', ','],
+  zh: [',', '.'],
+};
+
+export function getSeparatorsForLocale(locale) {
+  const country = locale.split('-')[0];
+  // Fall back to "en" if country is not mapped.
+  // NOTE: this is a temporary workaround until we refactor the `locale`
+  // to properly use "language + region" and therefore using `intl`
+  // to format numbers.
+  const countryFormat = formats[country.toLowerCase()] || formats.en;
+  const [thoSeparator, decSeparator] = countryFormat;
+
+  return {
+    thoSeparator,
+    decSeparator,
+  };
+}
+
+// Given a string, validates that it has the correct format
+// to be a number, with decimal separators and negative sign.
+export function isNumberish(number) {
+  return !/[^(\-?)\d,.\s]/.test(number);
+}
+
+export function isInteger(value) {
+  return /^-{0,1}\d*$/.test(value);
+}

package/src/utils/numbers/numbers.spec.js

@@ -0,0 +1,57 @@
+import * as numbers from './numbers';
+
+describe('check if number is valid', () => {
+  it('should pass positive number', () => {
+    expect(numbers.isNumberish('2')).toBe(true);
+  });
+
+  it('should pass decimal number with point', () => {
+    expect(numbers.isNumberish('2.2')).toBe(true);
+  });
+
+  it('should pass decimal number with comma', () => {
+    expect(numbers.isNumberish('2,2')).toBe(true);
+  });
+
+  it('should pass negative number', () => {
+    expect(numbers.isNumberish('-2')).toBe(true);
+  });
+});
+
+describe('check if integer is valid', () => {
+  it('should pass a positive number', () => {
+    expect(numbers.isInteger('2')).toBe(true);
+  });
+  it('should pass a negative number', () => {
+    expect(numbers.isInteger('-2')).toBe(true);
+  });
+  it('should fail a decimal number', () => {
+    expect(numbers.isInteger('2.3')).toBe(false);
+    expect(numbers.isInteger('2,3')).toBe(false);
+  });
+  it('should fail a string', () => {
+    expect(numbers.isInteger('hello123')).toBe(false);
+  });
+  it('should fail null', () => {
+    expect(numbers.isInteger(null)).toBe(false);
+  });
+  it('should fail undefined', () => {
+    expect(numbers.isInteger(undefined)).toBe(false);
+  });
+});
+
+describe('getSeparatorsForLocale', () => {
+  it('should return separators for locale "en"', () => {
+    expect(numbers.getSeparatorsForLocale('en')).toEqual({
+      thoSeparator: ',',
+      decSeparator: '.',
+    });
+  });
+  // Fixes: https://sentry.io/commercetools/mcng/issues/469626988/
+  it('should fall back to "en" format if locale is not supported', () => {
+    expect(numbers.getSeparatorsForLocale('es')).toEqual({
+      thoSeparator: ',',
+      decSeparator: '.',
+    });
+  });
+});

package/src/utils/omit-deep/index.js

@@ -0,0 +1 @@
+export { default } from './omit-deep';

package/src/utils/omit-deep/omit-deep.js

@@ -0,0 +1,20 @@
+import originalOmitDeep from 'omit-deep';
+
+// Custom wrapper of `omit-deep` that allows to deal with immutable objects.
+function omitDeep(obj, fieldsToOmit, options = {}) {
+  if (options.isImmutable) {
+    // We need to do a deep clone as the referenced object (for example coming from Apollo)
+    // could be frozen and considered immutable.
+    const mutable = JSON.parse(JSON.stringify(obj));
+
+    // Patch the object
+    const patched = originalOmitDeep(mutable, fieldsToOmit);
+    // Freeze the object again
+    return Object.freeze(patched);
+  }
+
+  // Omit the fields from the object as-is
+  return originalOmitDeep(obj, fieldsToOmit);
+}
+
+export default omitDeep;

package/src/utils/pim-query-clauses.js

@@ -0,0 +1,43 @@
+import compact from 'lodash.compact';
+
+const flattenOperator = (operator, clauses) =>
+  compact(
+    clauses.reduce(
+      (result, clause) => result.concat(clause?.[operator] || clause),
+      []
+    )
+  );
+
+const argsToArray = (args) =>
+  args.reduce((result, item) => result.concat(item), []);
+
+export const exists = (field, attributeType) => ({
+  exists: { field, attributeType },
+});
+
+export const exact = (field, value, attributeType, language) => ({
+  exact: { field, value, attributeType, language },
+});
+
+export const range = (field, attributeType, { gte, lte }) => ({
+  range: {
+    field,
+    attributeType,
+    gte,
+    lte,
+  },
+});
+
+export const or = (...clauses) => {
+  const clausesAsArray = flattenOperator('or', argsToArray(clauses));
+  return clausesAsArray.length > 1 ? { or: clausesAsArray } : clausesAsArray[0];
+};
+
+export const and = (...clauses) => {
+  const clausesAsArray = flattenOperator('and', argsToArray(clauses));
+  return clausesAsArray.length > 1
+    ? { and: clausesAsArray }
+    : clausesAsArray[0];
+};
+
+export const not = (...clauses) => ({ not: argsToArray(clauses) });

package/src/utils/prices/index.js

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

package/src/utils/prices/prices.js

@@ -0,0 +1,79 @@
+import has from 'lodash.has';
+import isNil from 'lodash.isnil';
+import { getFractionedAmount } from '../formats/money';
+import { PRECISION_TYPES } from '../constants';
+
+export function getPriceChannelName(price) {
+  return price.channel?.name ?? price.channel?.key ?? null;
+}
+
+export function getDiscountValue(price) {
+  let preciseAmount;
+  let fractionedAmount;
+  if (
+    price.value?.type === PRECISION_TYPES.highPrecision &&
+    price.discounted.value.type === PRECISION_TYPES.highPrecision
+  ) {
+    preciseAmount =
+      price.value.preciseAmount - price.discounted.value.preciseAmount;
+  } else if (
+    price.value?.type === PRECISION_TYPES.highPrecision &&
+    price.discounted?.value?.type === PRECISION_TYPES.centPrecision
+  ) {
+    fractionedAmount =
+      getFractionedAmount(price.value) -
+      getFractionedAmount(price.discounted.value);
+  }
+
+  return price.discounted
+    ? {
+        ...price.value,
+        fractionedAmount,
+        centAmount: price.value.centAmount - price.discounted.value.centAmount,
+        preciseAmount,
+      }
+    : { ...price.value, centAmount: 0 };
+}
+
+export function getSelectedPrice(price) {
+  return price.discounted ? price.discounted : price;
+}
+
+export function getNetUnitPrice({ lineItem, shouldRoundAmount }) {
+  const price = getSelectedPrice(lineItem.price);
+
+  if (lineItem.taxRate && lineItem.taxRate.includedInPrice) {
+    const centAmount = price.value.centAmount / (1 + lineItem.taxRate.amount);
+    let preciseAmount;
+    if (price.value?.type === PRECISION_TYPES.highPrecision)
+      preciseAmount = price.value.preciseAmount / (1 + lineItem.taxRate.amount);
+
+    return {
+      ...price.value,
+      centAmount: shouldRoundAmount ? Math.round(centAmount) : centAmount,
+      preciseAmount,
+    };
+  }
+  return price.value;
+}
+
+export function getMinimumPricesByCurrencyCode(prices) {
+  const minPricesByCurrency = prices.reduce((minPrices, price) => {
+    const currencyCode = price.value.currencyCode;
+    const fractionedAmount = getFractionedAmount(price.value);
+
+    if (currencyCode && !isNil(fractionedAmount)) {
+      if (
+        !minPrices[currencyCode] ||
+        fractionedAmount < getFractionedAmount(minPrices[currencyCode])
+      )
+        return {
+          ...minPrices,
+          [currencyCode]: price.value,
+        };
+    }
+    return minPrices;
+  }, {});
+
+  return Object.values(minPricesByCurrency);
+}