@adyen/adyen-platform-experience-web 1.0.0-beta → 1.0.0-beta.2

package/dist/es/core/Localization/Localization.test.js

@@ -1,70 +0,0 @@
-import { L as Localization } from "../../../index-c88cd37e.mjs";
-import { es_ES } from "./translations/index.js";
-import "../../utils/common/index.js";
-import { d as describe, t as test, g as globalExpect } from "../../../vendor-vi.a3ff54b1-5e924357.mjs";
-describe("Localization", () => {
-  describe("constructor", () => {
-    test("sets up locale and customTranslations", () => {
-      const lang = new Localization("es-ES", [es_ES]);
-      lang.customTranslations = {
-        "es-ES": { account: "es" }
-      };
-      lang.ready.then(() => {
-        globalExpect(lang.locale).toBe("es-ES");
-        globalExpect(lang.customTranslations["es-ES"]).toBeDefined();
-      });
-    });
-    test("sets up locale without country code and customTranslations without countryCode", () => {
-      const lang = new Localization("es", [es_ES]);
-      lang.customTranslations = {
-        es: { paymentId: "es" }
-      };
-      lang.ready.then(() => {
-        globalExpect(lang.locale).toBe("es-ES");
-        globalExpect(lang.customTranslations["es-ES"]).toBeDefined();
-      });
-    });
-    test("sets up a custom locale and customTranslations", () => {
-      const lang = new Localization("ca-CA");
-      lang.customTranslations = {
-        "ca-CA": { paymentId: "ca" }
-      };
-      lang.ready.then(() => {
-        globalExpect(lang.locale).toBe("ca-CA");
-        globalExpect(lang.customTranslations["ca-CA"]).toBeDefined();
-      });
-    });
-    test("sets up a custom locale without countryCode and customTranslations", () => {
-      const lang = new Localization("ca");
-      lang.customTranslations = {
-        "ca-CA": { paymentId: "ca" }
-      };
-      lang.ready.then(() => {
-        globalExpect(lang.locale).toBe("ca-CA");
-        globalExpect(lang.customTranslations["ca-CA"]).toBeDefined();
-      });
-    });
-    test("falls back to FALLBACK_LOCALE and removes customTranslations that do not match a language/language_country code", () => {
-      const lang = new Localization("FAKE");
-      lang.customTranslations = {
-        FAKE: { paymentId: "ca" }
-      };
-      lang.ready.then(() => {
-        globalExpect(lang.locale).toBe("en-US");
-        globalExpect(lang.customTranslations).toEqual({});
-      });
-    });
-  });
-  describe("get", () => {
-    test("gets a string even if it is empty", () => {
-      const lang = new Localization("en-US");
-      const translationKey = "paymentId";
-      lang.customTranslations = {
-        "en-US": { paymentId: "" }
-      };
-      lang.ready.then(() => {
-        globalExpect(lang.get(translationKey)).toBe(translationKey);
-      });
-    });
-  });
-});

package/dist/es/core/Localization/amount/amount-util.test.js

@@ -1,54 +0,0 @@
-import { isValidCurrencyCode, getDivider, getCurrencyCode, getLocalisedAmount, getLocalisedPercentage } from "./amount-util.js";
-import { d as describe, t as test, g as globalExpect, a as beforeAll, e as afterEach, c as afterAll, v as vi } from "../../../../vendor-vi.a3ff54b1-5e924357.mjs";
-describe("isValidCurrencyCode", () => {
-  test("should return true for BYN", () => {
-    globalExpect(isValidCurrencyCode("BYN")).toBe(true);
-  });
-  test("should return true for existing keys", () => {
-    globalExpect(isValidCurrencyCode("USD")).toBe(true);
-  });
-});
-describe("getDivider", () => {
-  test("should return the divider for a currency", () => {
-    globalExpect(getDivider("USD")).toBe(100);
-    globalExpect(getDivider("JPY")).toBe(1);
-    globalExpect(getDivider("BHD")).toBe(1e3);
-    globalExpect(getDivider("MRO")).toBe(10);
-  });
-});
-describe("getCurrencyCode", () => {
-  test("should return a currency symbol for existing keys", () => {
-    globalExpect(getCurrencyCode("USD")).toBe("$");
-    globalExpect(getCurrencyCode("BYN")).toBe("Br");
-  });
-});
-describe("getLocalisedAmount", () => {
-  let spyOnToLocaleString;
-  beforeAll(() => {
-    spyOnToLocaleString = vi.spyOn(Number.prototype, "toLocaleString");
-  });
-  afterEach(() => {
-    spyOnToLocaleString.mockClear();
-  });
-  afterAll(() => {
-    spyOnToLocaleString.mockRestore();
-  });
-  test("should return a formatted EUR amount", () => {
-    getLocalisedAmount(1e3, "nl-NL", "EUR");
-    globalExpect(spyOnToLocaleString).toHaveBeenCalledWith("nl-NL", { currency: "EUR", currencyDisplay: "symbol", style: "currency" });
-  });
-  test("should return a formatted USD amount", () => {
-    getLocalisedAmount(1e3, "en-US", "USD");
-    globalExpect(spyOnToLocaleString).toHaveBeenCalledWith("en-US", { currency: "USD", currencyDisplay: "symbol", style: "currency" });
-  });
-});
-describe("getLocalisedPercentage", () => {
-  test("should return a percentage formatted string", () => {
-    globalExpect(getLocalisedPercentage(1e3, "en-US")).toBe("10%");
-    globalExpect(getLocalisedPercentage(100, "en-US")).toBe("1%");
-    globalExpect(getLocalisedPercentage(10, "en-US")).toBe("0.1%");
-    globalExpect(getLocalisedPercentage(1, "en-US")).toBe("0.01%");
-    globalExpect(getLocalisedPercentage(1234, "en-US")).toBe("12.34%");
-    globalExpect(getLocalisedPercentage(-2500, "en-US")).toBe("-25%");
-  });
-});

package/dist/es/core/Localization/datetime/restamper/index.js

@@ -1,9 +0,0 @@
-import { default as default2 } from "./restamper.js";
-import { SYSTEM_TIMEZONE } from "./constants.js";
-import { systemToTimezone, timezoneToSystem } from "./utils.js";
-export {
-  SYSTEM_TIMEZONE,
-  default2 as default,
-  systemToTimezone,
-  timezoneToSystem
-};

package/dist/es/core/Localization/datetime/restamper/restamper.test.js

@@ -1,179 +0,0 @@
-import { h as getWorkerState, c as afterAll, e as afterEach, j as assert, a as beforeAll, b as beforeEach, k as bench, l as chai, m as createExpect, d as describe, g as globalExpect, i as it, o as onTestFailed, s as setupChaiConfig, n as should, p as suite, t as test, v as vi, q as vitest } from "../../../../../vendor-vi.a3ff54b1-5e924357.mjs";
-import { REGEX_TZ_OFFSET } from "./constants.js";
-import restamper from "./restamper.js";
-import { NON_DST_TIMEZONES, DST_TIMEZONES } from "./testing/fixtures.js";
-import { getPastDatesMapForEachMonthInYear, runTimezoneTestRoutine } from "./testing/helpers.js";
-const filesCount = /* @__PURE__ */ new Map();
-const cache = /* @__PURE__ */ new Map();
-function runOnce(fn, key) {
-  const filepath = getWorkerState().filepath || "__unknown_files__";
-  if (!key) {
-    filesCount.set(filepath, (filesCount.get(filepath) || 0) + 1);
-    key = String(filesCount.get(filepath));
-  }
-  const id = `${filepath}:${key}`;
-  if (!cache.has(id))
-    cache.set(id, fn());
-  return cache.get(id);
-}
-function isFirstRun() {
-  let firstRun = false;
-  runOnce(() => {
-    firstRun = true;
-  }, "__vitest_first_run__");
-  return firstRun;
-}
-function getRunningMode() {
-  return process.env.VITEST_MODE === "WATCH" ? "watch" : "run";
-}
-function isWatchMode() {
-  return getRunningMode() === "watch";
-}
-var dist = {};
-(function(exports) {
-  Object.defineProperty(exports, "__esModule", { value: true });
-  exports.expectTypeOf = void 0;
-  const fn = () => true;
-  const expectTypeOf2 = (_actual) => {
-    const nonFunctionProperties = [
-      "parameters",
-      "returns",
-      "resolves",
-      "not",
-      "items",
-      "constructorParameters",
-      "instance",
-      "guards",
-      "asserts"
-    ];
-    const obj = {
-      /* eslint-disable mmkal/@typescript-eslint/no-unsafe-assignment */
-      toBeAny: fn,
-      toBeUnknown: fn,
-      toBeNever: fn,
-      toBeFunction: fn,
-      toBeObject: fn,
-      toBeArray: fn,
-      toBeString: fn,
-      toBeNumber: fn,
-      toBeBoolean: fn,
-      toBeVoid: fn,
-      toBeSymbol: fn,
-      toBeNull: fn,
-      toBeUndefined: fn,
-      toBeNullable: fn,
-      toMatchTypeOf: fn,
-      toEqualTypeOf: fn,
-      toBeCallableWith: fn,
-      toBeConstructibleWith: fn,
-      /* eslint-enable mmkal/@typescript-eslint/no-unsafe-assignment */
-      extract: exports.expectTypeOf,
-      exclude: exports.expectTypeOf,
-      toHaveProperty: exports.expectTypeOf,
-      parameter: exports.expectTypeOf
-    };
-    const getterProperties = nonFunctionProperties;
-    getterProperties.forEach((prop) => Object.defineProperty(obj, prop, { get: () => (0, exports.expectTypeOf)({}) }));
-    return obj;
-  };
-  exports.expectTypeOf = expectTypeOf2;
-})(dist);
-function noop() {
-}
-const assertType = noop;
-/* @__PURE__ */ Object.freeze({
-  __proto__: null,
-  afterAll,
-  afterEach,
-  assert,
-  assertType,
-  beforeAll,
-  beforeEach,
-  bench,
-  chai,
-  createExpect,
-  describe,
-  expect: globalExpect,
-  expectTypeOf: dist.expectTypeOf,
-  getRunningMode,
-  isFirstRun,
-  isWatchMode,
-  it,
-  onTestFailed,
-  runOnce,
-  setupChaiConfig,
-  should,
-  suite,
-  test,
-  vi,
-  vitest
-});
-var expectTypeOf = dist.expectTypeOf;
-describe("restamper", () => {
-  beforeEach((context) => {
-    const _restamper = restamper();
-    Object.defineProperties(context, {
-      currentOffset: { value: _restamper().offset, enumerable: true },
-      restamper: { value: _restamper, enumerable: true },
-      timezone: { value: _restamper.tz, enumerable: true }
-    });
-  });
-  test("should return restamp instance", ({ restamper: restamper2, timezone }) => {
-    const { system: systemTimezone } = timezone;
-    const invalidTimezone = "Unknown/Invalid_TZ";
-    const validTimezone = "Asia/Tokyo";
-    expectTypeOf(restamper2);
-    expectTypeOf(restamper2());
-    expectTypeOf(restamper2(/* @__PURE__ */ new Date("2012-08-22")));
-    expectTypeOf(timezone);
-    globalExpect(restamper2).toHaveProperty("tz");
-    globalExpect(timezone).toHaveProperty("current");
-    globalExpect(timezone).toHaveProperty("system");
-    globalExpect(timezone.system).toBeTypeOf("string");
-    globalExpect(timezone.current).toBeTypeOf("string");
-    globalExpect(timezone.current).toBe(timezone.system);
-    restamper2.tz = validTimezone;
-    globalExpect(timezone.current).toBe(validTimezone);
-    globalExpect(timezone.system).toBe(systemTimezone);
-    restamper2.tz = invalidTimezone;
-    globalExpect(timezone.current).not.toBe(invalidTimezone);
-    globalExpect(timezone.current).toBe(validTimezone);
-    globalExpect(timezone.system).toBe(systemTimezone);
-  });
-  test("should return restamp result for current time (when argument is omitted)", ({ restamper: restamper2 }) => {
-    let result = restamper2();
-    globalExpect(result).toHaveProperty("formatted");
-    globalExpect(result).toHaveProperty("offset");
-    globalExpect(result).toHaveProperty("timestamp");
-    globalExpect(result.offset).toBeTypeOf("number");
-    globalExpect(result.offset).toBe(0);
-    globalExpect(result.timestamp).toBeTypeOf("number");
-    globalExpect(result.timestamp).toBeCloseTo(Date.now(), -2);
-    if (result.formatted !== void 0) {
-      globalExpect(result.formatted).toBeTypeOf("string");
-      globalExpect(REGEX_TZ_OFFSET.test(result.formatted)).toBe(true);
-    }
-  });
-  test("should have correct offsets for non-DST timezones for times in the past", ({ restamper: restamper2 }) => {
-    const pastDatesMap = getPastDatesMapForEachMonthInYear(restamper2);
-    NON_DST_TIMEZONES.forEach((timezoneOffset, timezone) => {
-      restamper2.tz = timezone;
-      pastDatesMap.forEach((systemTimezoneResult, date) => {
-        const result = restamper2(date);
-        runTimezoneTestRoutine(timezoneOffset, systemTimezoneResult, result);
-      });
-    });
-  });
-  test("should have correct offsets for DST timezones for times in the past", ({ restamper: restamper2 }) => {
-    const pastDatesMap = getPastDatesMapForEachMonthInYear(restamper2);
-    DST_TIMEZONES.forEach((timezoneOffsets, timezone) => {
-      restamper2.tz = timezone;
-      let index = 0;
-      for (const [date, systemTimezoneResult] of pastDatesMap) {
-        const result = restamper2(date);
-        const timezoneOffsetForCurrentTime = timezoneOffsets[index++];
-        runTimezoneTestRoutine(timezoneOffsetForCurrentTime, systemTimezoneResult, result);
-      }
-    });
-  });
-});

package/dist/es/core/Localization/datetime/restamper/testing/fixtures.js

@@ -1,21 +0,0 @@
-const TIMEZONE_PAST_DATES_TEST_ORIGIN_DATE = "2021-12-21 10:53:07 AM";
-const DST_TIMEZONES = /* @__PURE__ */ new Map([
-  ["America/Toronto", [-300, -300, -240, -240, -240, -240, -240, -240, -240, -240, -300, -300]],
-  ["Asia/Jerusalem", [120, 120, 120, 180, 180, 180, 180, 180, 180, 180, 120, 120]],
-  ["Australia/Lord_Howe", [660, 660, 660, 630, 630, 630, 630, 630, 630, 660, 660, 660]],
-  ["Europe/Lisbon", [0, 0, 0, 60, 60, 60, 60, 60, 60, 60, 0, 0]],
-  ["Pacific/Chatham", [825, 825, 825, 765, 765, 765, 765, 765, 765, 825, 825, 825]]
-]);
-const NON_DST_TIMEZONES = /* @__PURE__ */ new Map([
-  ["Africa/Lagos", 60],
-  ["America/Phoenix", -420],
-  ["America/Sao_Paulo", -180],
-  ["Asia/Kabul", 270],
-  ["Asia/Tokyo", 540],
-  ["Australia/Eucla", 525]
-]);
-export {
-  DST_TIMEZONES,
-  NON_DST_TIMEZONES,
-  TIMEZONE_PAST_DATES_TEST_ORIGIN_DATE
-};

package/dist/es/core/Localization/datetime/restamper/testing/helpers.js

@@ -1,27 +0,0 @@
-import { TIMEZONE_PAST_DATES_TEST_ORIGIN_DATE } from "./fixtures.js";
-import { getGMTSuffixForTimezoneOffset, getSystemTimezoneGMTSuffixFromTimezoneOffsets } from "../utils.js";
-import { g as globalExpect } from "../../../../../../vendor-vi.a3ff54b1-5e924357.mjs";
-const getPastDatesMapForEachMonthInYear = (restamper) => {
-  const pastDate = new Date(TIMEZONE_PAST_DATES_TEST_ORIGIN_DATE);
-  return new Map(
-    Array.from({ length: 12 }, () => {
-      pastDate.setMonth(pastDate.getMonth() + 1);
-      return [pastDate.toISOString(), restamper(pastDate)];
-    })
-  );
-};
-const runTimezoneTestRoutine = (timezoneOffset, systemTimezoneResult, result) => {
-  if (result.formatted !== void 0) {
-    const TimezoneGMTSuffix = getGMTSuffixForTimezoneOffset(timezoneOffset);
-    globalExpect(result.formatted).toMatch(TimezoneGMTSuffix);
-  }
-  if (systemTimezoneResult.formatted !== void 0) {
-    const SystemTimezoneGMTSuffix = getSystemTimezoneGMTSuffixFromTimezoneOffsets(timezoneOffset, result.offset);
-    globalExpect(systemTimezoneResult.formatted).toMatch(SystemTimezoneGMTSuffix);
-  }
-  globalExpect(result.timestamp).toBe(systemTimezoneResult.timestamp);
-};
-export {
-  getPastDatesMapForEachMonthInYear,
-  runTimezoneTestRoutine
-};

package/dist/es/core/Localization/index.js

@@ -1,32 +0,0 @@
-import { L } from "../../../index-c88cd37e.mjs";
-import { all_locales, ar, cs_CZ, da_DK, de_DE, el_GR, en_US, es_ES, fi_FI, fr_FR, hr_HR, hu_HU, it_IT, ja_JP, ko_KR, nl_NL, no_NO, pl_PL, pt_BR, pt_PT, ro_RO, ru_RU, sk_SK, sl_SI, sv_SE, zh_CN, zh_TW } from "./translations/index.js";
-export {
-  all_locales,
-  ar,
-  cs_CZ,
-  da_DK,
-  de_DE,
-  L as default,
-  el_GR,
-  en_US,
-  es_ES,
-  fi_FI,
-  fr_FR,
-  hr_HR,
-  hu_HU,
-  it_IT,
-  ja_JP,
-  ko_KR,
-  nl_NL,
-  no_NO,
-  pl_PL,
-  pt_BR,
-  pt_PT,
-  ro_RO,
-  ru_RU,
-  sk_SK,
-  sl_SI,
-  sv_SE,
-  zh_CN,
-  zh_TW
-};

package/dist/es/core/Localization/utils.test.js

@@ -1,215 +0,0 @@
-import { parseLocale, matchLocale, formatLocale, getTranslation, formatCustomTranslations, loadTranslations, interpolateElement } from "./utils.js";
-import { y } from "../../../preact.module-38e5a571.mjs";
-import { SUPPORTED_LOCALES } from "./constants/localization.js";
-import { d as describe, t as test, g as globalExpect } from "../../../vendor-vi.a3ff54b1-5e924357.mjs";
-const defaultSupportedLocales = SUPPORTED_LOCALES;
-describe("parseLocale()", () => {
-  test("should return the passed locale if formatted properly", () => {
-    globalExpect(parseLocale("en-US", defaultSupportedLocales)).toBe("en-US");
-    globalExpect(parseLocale("zh-TW", defaultSupportedLocales)).toBe("zh-TW");
-    globalExpect(parseLocale("zh-CN", defaultSupportedLocales)).toBe("zh-CN");
-    globalExpect(parseLocale("da-DK", defaultSupportedLocales)).toBe("da-DK");
-  });
-  test("should return a properly formatted locale if not formatted", () => {
-    const locale = "En_us";
-    globalExpect(parseLocale(locale, defaultSupportedLocales)).toBe("en-US");
-  });
-  test("should return a properly formatted locale when a partial locale is sent in", () => {
-    const locale = "nl";
-    globalExpect(parseLocale(locale, defaultSupportedLocales)).toBe("nl-NL");
-  });
-  test("should return the FALLBACK_LOCALE when an incorrect locale is sent in", () => {
-    globalExpect(parseLocale("default", defaultSupportedLocales)).toBe("en-US");
-    globalExpect(parseLocale("english", defaultSupportedLocales)).toBe("en-US");
-    globalExpect(parseLocale("spanish", defaultSupportedLocales)).toBe("en-US");
-  });
-  test("should return FALLBACK_LOCALE when an empty string is send", () => {
-    globalExpect(parseLocale("", defaultSupportedLocales)).toBe("en-US");
-  });
-  test("should return null when a locale is not matched", () => {
-    const locale = "xx_XX";
-    globalExpect(parseLocale(locale, defaultSupportedLocales)).toBe(null);
-  });
-  test("should return a formatted locale when called with an underscored locale like en_US", () => {
-    const locale = "en_US";
-    globalExpect(parseLocale(locale, defaultSupportedLocales)).toBe("en-US");
-  });
-  test("should return the matched language when called with a non-proper locale like es&ES", () => {
-    const locale = "es&ES";
-    globalExpect(parseLocale(locale, defaultSupportedLocales)).toBe("es-ES");
-  });
-});
-describe("matchLocale()", () => {
-  test("should match a two letter code", () => {
-    globalExpect(matchLocale("en", [...defaultSupportedLocales])).toBe("en-US");
-    globalExpect(matchLocale("es", [...defaultSupportedLocales])).toBe("es-ES");
-  });
-  test("should return null if it cannot match the locale", () => {
-    globalExpect(matchLocale("ca", [...defaultSupportedLocales])).toBe(null);
-    globalExpect(matchLocale("ne", [...defaultSupportedLocales])).toBe(null);
-    globalExpect(matchLocale("123", [...defaultSupportedLocales])).toBe(null);
-  });
-});
-describe("formatLocale()", () => {
-  test("should not do anything if the locale is already formatted", () => {
-    globalExpect(formatLocale("en-US")).toBe("en-US");
-    globalExpect(formatLocale("es-ES")).toBe("es-ES");
-  });
-  test("should return null if the locale is missing a part or it is not properly separated", () => {
-    globalExpect(formatLocale("en")).toBe(null);
-    globalExpect(formatLocale("enUS")).toBe(null);
-  });
-  test("should return a formatted locale when called with an underscored locale like en_US", () => {
-    globalExpect(formatLocale("en_us")).toBe("en-US");
-  });
-  test("should return a formatted locale when called with a lowercase locale like en-us", () => {
-    globalExpect(formatLocale("en-us")).toBe("en-US");
-  });
-});
-describe("getTranslation()", () => {
-  const translations = {
-    myTranslation: "My translation",
-    myTranslation__plural: "My translations",
-    myTranslation__2: "My two translations"
-  };
-  test("should get a translation with a matching key", () => {
-    globalExpect(getTranslation(translations, "myTranslation")).toBe("My translation");
-  });
-  test("should get a translation with values", () => {
-    globalExpect(getTranslation({ myTranslation: "My %{type} translation" }, "myTranslation", { values: { type: "custom" } })).toBe(
-      "My custom translation"
-    );
-  });
-  test("should get a translation with empty values", () => {
-    globalExpect(getTranslation({ myTranslation: "My %{type} translation" }, "myTranslation")).toBe("My  translation");
-  });
-  test("should get a plural translation if available", () => {
-    globalExpect(getTranslation(translations, "myTranslation", { count: 3 })).toBe("My translations");
-  });
-  test("should get a specific count translation if available", () => {
-    globalExpect(getTranslation(translations, "myTranslation", { count: 2 })).toBe("My two translations");
-  });
-  test("should get the default translation if count is not greater than 1", () => {
-    globalExpect(getTranslation(translations, "myTranslation", { count: 1 })).toBe("My translation");
-    globalExpect(getTranslation(translations, "myTranslation", { count: 0 })).toBe("My translation");
-    globalExpect(getTranslation(translations, "myTranslation", { count: -1 })).toBe("My translation");
-  });
-  test("should get the default translation if count is not provided", () => {
-    globalExpect(getTranslation(translations, "myTranslation")).toBe("My translation");
-  });
-});
-describe("formatCustomTranslations()", () => {
-  test("should work when no custom translations are passed", () => {
-    globalExpect(formatCustomTranslations({}, defaultSupportedLocales)).toEqual({});
-    globalExpect(formatCustomTranslations(void 0, defaultSupportedLocales)).toEqual({});
-  });
-  test("should work when custom translations are already in the defaultSupportedLocales", () => {
-    const customTranslations = {
-      "en-US": {
-        paymentId: "customString"
-      }
-    };
-    globalExpect(formatCustomTranslations(customTranslations, defaultSupportedLocales)).toEqual(customTranslations);
-  });
-  test("should work when custom translations contain a partial ", () => {
-    const customTranslations = {
-      en: {
-        paymentId: "customString"
-      }
-    };
-    const expectedCustomTranslations = {
-      "en-US": {
-        paymentId: "customString"
-      }
-    };
-    globalExpect(formatCustomTranslations(customTranslations, defaultSupportedLocales)).toEqual(expectedCustomTranslations);
-  });
-  test("should format new locales", () => {
-    const customTranslations = {
-      "es-ar": {
-        paymentId: "customString"
-      }
-    };
-    const expectedCustomTranslations = {
-      "es-AR": {
-        paymentId: "customString"
-      }
-    };
-    globalExpect(formatCustomTranslations(customTranslations, defaultSupportedLocales)).toEqual(expectedCustomTranslations);
-  });
-  test("should format new locales", () => {
-    const customTranslations = {
-      "ca-ca": {
-        paymentId: "customString"
-      }
-    };
-    const expectedCustomTranslations = {
-      "ca-CA": {
-        paymentId: "customString"
-      }
-    };
-    globalExpect(formatCustomTranslations(customTranslations, defaultSupportedLocales)).toEqual(expectedCustomTranslations);
-  });
-  test("should format new partial locales if properly added in the defaultSupportedLocales", () => {
-    const customTranslations = {
-      ca: {
-        paymentId: "customString"
-      }
-    };
-    const defaultSupportedLocales2 = ["es-ES", "ca-CA"];
-    const expectedCustomTranslations = {
-      "ca-CA": {
-        paymentId: "customString"
-      }
-    };
-    globalExpect(formatCustomTranslations(customTranslations, defaultSupportedLocales2)).toEqual(expectedCustomTranslations);
-  });
-});
-describe("loadTranslations()", () => {
-  test("should accept customTranslations without a countryCode for default defaultSupportedLocales", () => {
-    loadTranslations("es-ES", {
-      "es-ES": {
-        account: "es-ES account"
-      },
-      "es-AR": {
-        account: "es-AR account"
-      }
-    }).then((translations) => {
-      globalExpect(translations["account"]).toBe("es-ES account");
-    });
-  });
-  test("should return the passed locale if formatted properly", () => {
-    loadTranslations(
-      "ca-CA",
-      {
-        "es-ES": {
-          paymentId: "paymentId es-ES"
-        },
-        "ca-CA": {
-          paymentId: "paymentId ca-CA"
-        }
-      }
-    ).then((translations) => {
-      globalExpect(translations["paymentId"]).toBe("paymentId ca-CA");
-    });
-  });
-  test("should return the passed locale if formatted properly", () => {
-    loadTranslations("ca-CA", {
-      "ca-CA": {
-        "status.active": "status.active ca-CA"
-      }
-    }).then((translations) => {
-      globalExpect(translations["status.active"]).toBe("status.active ca-CA");
-    });
-  });
-});
-describe("interpolateElement()", () => {
-  test("it should interpolate the element properly", () => {
-    const renderLink = (translation) => y("a", { href: "example.com" }, [translation]);
-    const result = interpolateElement("By clicking continue %#you%# agree with the %#term and conditions%#", [renderLink, renderLink]);
-    globalExpect(typeof result[0] === "string");
-    globalExpect(result[1] === "a");
-    globalExpect(typeof result[2] === "string");
-    globalExpect(result[3] === "a");
-  });
-});

package/dist/es/core/ProcessResponse/index.js

@@ -1,4 +0,0 @@
-import { processResponse } from "./process-response.js";
-export {
-  processResponse as default
-};

package/dist/es/core/ProcessResponse/process-response.js

@@ -1,40 +0,0 @@
-const processCompleteResponse = (response) => {
-  var _a;
-  switch ((_a = response.resultCode) == null ? void 0 : _a.toLowerCase()) {
-    case "refused":
-    case "error":
-    case "cancelled":
-      return { type: "error", props: { ...response, message: "error.subtitle.refused" } };
-    case "unknown":
-      return { type: "error", props: { ...response, message: "error.message.unknown" } };
-    case "pending":
-    case "received":
-      return { type: response.resultCode.toLowerCase(), props: response };
-    case "authorised":
-      return { type: "success", props: response };
-    default:
-      return { type: "success", props: response };
-  }
-};
-const processResponse = (response) => {
-  if (!response.type && response.resultCode) {
-    return processCompleteResponse(response);
-  }
-  if (!response.type) {
-    return { type: "error", props: response };
-  }
-  switch (response.type.toLowerCase()) {
-    case "pending":
-      return { type: "pending", props: response };
-    case "complete":
-      return processCompleteResponse(response);
-    case "validation":
-      return { type: "error", props: response };
-    default:
-      return { type: "error", props: response };
-  }
-};
-export {
-  processResponse as default,
-  processResponse
-};