@adyen/adyen-platform-experience-web 0.1.1 → 1.0.0-beta

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

@@ -0,0 +1,215 @@
+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

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

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

@@ -0,0 +1,40 @@
+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
+};

package/dist/es/core/Services/analytics/collect-id.js

@@ -0,0 +1,37 @@
+import { httpPost } from "../requests/http.js";
+import Storage from "../../../utils/Storage.js";
+function confirmSessionDurationIsMaxFifteenMinutes(checkoutAttemptIdSession) {
+  if (!(checkoutAttemptIdSession == null ? void 0 : checkoutAttemptIdSession.id))
+    return false;
+  const fifteenMinInMs = 1e3 * 60 * 15;
+  const fifteenMinAgoTimestamp = Date.now() - fifteenMinInMs;
+  return checkoutAttemptIdSession.timestamp > fifteenMinAgoTimestamp;
+}
+const collectId = ({ loadingContext, experiments }) => {
+  let promise;
+  const options = {
+    errorLevel: "silent",
+    loadingContext,
+    path: `v2/analytics/id`
+  };
+  return () => {
+    if (promise)
+      return promise;
+    const storage = new Storage("checkout-attempt-id", window.sessionStorage);
+    const checkoutAttemptIdSession = storage.get();
+    if (checkoutAttemptIdSession && confirmSessionDurationIsMaxFifteenMinutes(checkoutAttemptIdSession)) {
+      return Promise.resolve(checkoutAttemptIdSession.id);
+    }
+    promise = httpPost(options, { experiments }).then((conversion) => {
+      if (conversion.id) {
+        storage.set({ id: conversion.id, timestamp: Date.now() });
+        return conversion.id;
+      }
+      return void 0;
+    }).catch(() => void 0);
+    return promise;
+  };
+};
+export {
+  collectId as default
+};

package/dist/es/core/Services/analytics/log-event.js

@@ -0,0 +1,14 @@
+const logEvent = (config) => (event) => {
+  const params = {
+    version: process.env.VERSION,
+    payload_version: 1,
+    platform: "web",
+    locale: config.locale,
+    ...event
+  };
+  const queryString = Object.keys(params).map((key) => `${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`).join("&");
+  new Image().src = `${config.loadingContext}images/analytics.png?${queryString}`;
+};
+export {
+  logEvent as default
+};

package/dist/es/core/Services/analytics/post-telemetry.js

@@ -0,0 +1,22 @@
+import { httpPost } from "../requests/http.js";
+const logTelemetry = (config) => (event) => {
+  const options = {
+    errorLevel: "silent",
+    loadingContext: config.loadingContext,
+    path: `v2/analytics/log`
+  };
+  const telemetryEvent = {
+    version: process.env.VERSION,
+    channel: "Web",
+    locale: config.locale,
+    flavor: "components",
+    userAgent: navigator.userAgent,
+    referrer: window.location.href,
+    screenWidth: window.screen.width,
+    ...event
+  };
+  return httpPost(options, telemetryEvent);
+};
+export {
+  logTelemetry as default
+};

package/dist/es/core/Services/data-set.js

@@ -0,0 +1 @@
+

package/dist/es/core/Services/get-dataset.js

@@ -0,0 +1,13 @@
+import { httpGet } from "./requests/http.js";
+function getDataset(name, loadingContext, locale) {
+  const options = {
+    loadingContext: loadingContext ?? "",
+    errorLevel: "warn",
+    errorMessage: `Dataset ${name} is not available`,
+    path: locale ? `datasets/${name}/${locale}.json` : `datasets/${name}.json`
+  };
+  return httpGet(options);
+}
+export {
+  getDataset as default
+};

package/dist/es/core/Services/requests/endpoints.js

@@ -0,0 +1,9 @@
+const API_ENDPOINTS = {
+  transactions: {
+    getTransactions: "/transactions",
+    getTransactionsById: (id) => `/transactions/${id}`
+  }
+};
+export {
+  API_ENDPOINTS
+};

package/dist/es/core/Services/requests/http.js

@@ -1,32 +1,59 @@
-import { API_VERSION as f } from "../sessions/constants.js";
-import u from "../../Errors/AdyenFPError.js";
-import { getRequestObject as g, getErrorType as h, isAdyenErrorResponse as p, handleFetchError as c } from "./utils.js";
-import { normalizeLoadingContext as y, normalizeUrl as C } from "../../utils.js";
-function E(e, n) {
-  const { errorLevel: s, loadingContext: l = "", path: d } = e, i = g(e, n), a = new URL(`${y(l)}${f}${C(d)}`);
-  return e.params && e.params.forEach((t, r) => {
-    const o = decodeURIComponent(t);
-    o && a.searchParams.append(r, o);
-  }), fetch(a, i).then(async (t) => {
-    const r = await t.json();
-    if (t.ok)
-      return await r;
-    const o = h(t.status);
-    if (p(r))
-      return e.errorHandler ? e.errorHandler(r) : c({ message: r.detail, level: s, errorCode: r.errorCode, type: o });
-    const m = e.errorMessage || `Service at ${a} is not available`;
-    return c({ message: m, level: s, errorCode: String(r.status), type: o });
-  }).catch((t) => {
-    if (t instanceof u)
-      throw t;
-    const r = e.errorMessage || `Call to ${a} failed. Error= ${t}`;
-    c({ message: r, level: s });
-  });
+import { API_VERSION } from "../sessions/constants.js";
+import { getRequestObject, getErrorType, isAdyenErrorResponse, handleFetchError } from "./utils.js";
+import { normalizeLoadingContext, normalizeUrl } from "../../utils.js";
+async function http(options, data) {
+  const { errorLevel, loadingContext = "", path } = options;
+  const request = getRequestObject(options, data);
+  const url = new URL(`${normalizeLoadingContext(loadingContext)}${API_VERSION}${normalizeUrl(path)}`);
+  if (options.params) {
+    options.params.forEach((value, param) => {
+      const decodedValue = decodeURIComponent(value);
+      if (decodedValue)
+        url.searchParams.append(param, decodedValue);
+    });
+  }
+  return (async () => {
+    const error = { level: errorLevel };
+    let errorPassThrough = false;
+    handle: {
+      try {
+        const res = await fetch(url, request);
+        if (res.ok) {
+          errorPassThrough = true;
+          return await res.json();
+        }
+        error.type = getErrorType(res.status);
+        const response = await res.json();
+        error.message = options.errorMessage || `Service at ${url} is not available`;
+        error.errorCode = String(response.status);
+        error.requestId = response == null ? void 0 : response.requestId;
+        if (isAdyenErrorResponse(response)) {
+          if (options.errorHandler) {
+            errorPassThrough = true;
+            options.errorHandler(response);
+            break handle;
+          }
+          error.message = response.detail;
+          error.errorCode = response.errorCode;
+        }
+      } catch (ex) {
+        if (errorPassThrough) {
+          throw ex;
+        }
+        error.message = options.errorMessage || `Call to ${url} failed. Error= ${ex}`;
+      }
+      handleFetchError(error);
+    }
+  })();
 }
-function w(e, n) {
-  return E({ ...e, method: "POST" }, n);
+function httpGet(options) {
+  return http({ ...options, method: "GET" });
+}
+function httpPost(options, data) {
+  return http({ ...options, method: "POST" }, data);
 }
 export {
-  E as http,
-  w as httpPost
+  http,
+  httpGet,
+  httpPost
 };

package/dist/es/core/Services/requests/utils.js

@@ -1,65 +1,80 @@
-import R from "../../Errors/AdyenFPError.js";
-var c = /* @__PURE__ */ ((e) => (e.NETWORK_ERROR = "NETWORK_ERROR", e.CANCEL = "CANCEL", e.IMPLEMENTATION_ERROR = "IMPLEMENTATION_ERROR", e.ERROR = "ERROR", e.EXPIRED_TOKEN = "EXPIRED_TOKEN", e))(c || {});
-const i = (e) => {
-  switch (e) {
+import AdyenPlatformExperienceError from "../../Errors/AdyenPlatformExperienceError.js";
+var ErrorTypes = /* @__PURE__ */ ((ErrorTypes2) => {
+  ErrorTypes2["NETWORK_ERROR"] = "NETWORK_ERROR";
+  ErrorTypes2["CANCEL"] = "CANCEL";
+  ErrorTypes2["IMPLEMENTATION_ERROR"] = "IMPLEMENTATION_ERROR";
+  ErrorTypes2["ERROR"] = "ERROR";
+  ErrorTypes2["EXPIRED_TOKEN"] = "EXPIRED_TOKEN";
+  return ErrorTypes2;
+})(ErrorTypes || {});
+const getErrorType = (errorCode) => {
+  switch (errorCode) {
     case 401:
       return "EXPIRED_TOKEN";
     default:
       return "NETWORK_ERROR";
   }
-}, a = (e, n) => {
-  const { headers: t = [], method: r = "GET" } = e;
+};
+const getRequestObject = (options, data) => {
+  const { headers = [], method = "GET" } = options;
   return {
-    method: r,
+    method,
     mode: "cors",
     cache: "default",
     credentials: "same-origin",
     headers: {
       Accept: "application/json, text/plain, */*",
       "Content-Type": "application/json",
-      ...t
+      ...headers
     },
     redirect: "follow",
-    signal: e.signal,
+    signal: options.signal,
     referrerPolicy: "no-referrer-when-downgrade",
-    ...r === "POST" && n && { body: JSON.stringify(n) }
+    ...method === "POST" && data && { body: JSON.stringify(data) }
   };
 };
-function E({
-  message: e,
-  level: n,
-  errorCode: t,
-  type: r = "NETWORK_ERROR"
-  /* NETWORK_ERROR */
+function handleFetchError({
+  message,
+  level,
+  errorCode,
+  type = "NETWORK_ERROR",
+  requestId
 }) {
-  switch (n) {
-    case "silent":
+  switch (level) {
+    case "silent": {
       break;
+    }
     case "info":
     case "warn":
-      console[n](e);
+      console[level](message);
       break;
     case "error":
     default:
-      throw new R(r, e, t);
+      throw new AdyenPlatformExperienceError(type, requestId, message, errorCode);
   }
 }
-function O(e) {
-  return e && e.errorCode && e.type && (e.detail || e.invalidFields) && e.status;
+function isAdyenErrorResponse(data) {
+  return data && data.errorCode && data.type && (data.detail || data.invalidFields) && data.status;
 }
-function l(e) {
-  const n = new URLSearchParams();
-  for (const t of Object.keys(e)) {
-    const r = e[t];
-    r != null && (Array.isArray(r) ? r.forEach((o) => n.append(t, o)) : n.set(t, String(r)));
+function parseSearchParams(parameters) {
+  const params = new URLSearchParams();
+  for (const param of Object.keys(parameters)) {
+    const value = parameters[param];
+    if (value !== void 0 && value !== null) {
+      if (Array.isArray(value)) {
+        value.forEach((item) => params.append(param, item));
+      } else {
+        params.set(param, String(value));
+      }
+    }
   }
-  return n;
+  return params;
 }
 export {
-  c as ErrorTypes,
-  i as getErrorType,
-  a as getRequestObject,
-  E as handleFetchError,
-  O as isAdyenErrorResponse,
-  l as parseSearchParams
+  ErrorTypes,
+  getErrorType,
+  getRequestObject,
+  handleFetchError,
+  isAdyenErrorResponse,
+  parseSearchParams
 };

package/dist/es/core/Services/sessions/constants.js

@@ -1,4 +1,4 @@
-const o = "v1";
+const API_VERSION = "v1";
 export {
-  o as API_VERSION
+  API_VERSION
 };

package/dist/es/core/Services/sessions/setup-session.js

@@ -1,20 +1,20 @@
-import { httpPost as r } from "../requests/http.js";
-function n(t, e) {
-  const o = "/setup";
-  return r(
+import { httpPost } from "../requests/http.js";
+function setupSession(session, options) {
+  const path = `/setup`;
+  return httpPost(
     {
       errorLevel: "fatal",
       errorMessage: "ERROR: Invalid ClientKey",
-      ...e ?? {},
-      loadingContext: t.loadingContext,
-      path: o,
+      ...options ?? {},
+      loadingContext: session.loadingContext,
+      path,
       headers: {
-        Authorization: `Bearer ${t.token}`
+        Authorization: `Bearer ${session.token}`
       }
     },
     {}
   );
 }
 export {
-  n as default
+  setupSession as default
 };