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

package/dist/es/utils/Validator/defaultRules.js

@@ -0,0 +1,12 @@
+const defaultRules = {
+  input: {
+    default: () => true
+  },
+  blur: {
+    shopperEmail: (email) => /\S+@\S+\.\S+/.test(email),
+    default: () => true
+  }
+};
+export {
+  defaultRules as default
+};

package/dist/es/utils/Validator/index.js

@@ -0,0 +1,4 @@
+import { default as default2 } from "./Validator.js";
+export {
+  default2 as default
+};

package/dist/es/utils/class-name-utils.js

@@ -1,7 +1,13 @@
-import r from "classnames";
-const e = /^\s+|\s+(?=\s|$)/g, p = (n, t) => (t ? typeof t == "string" ? t : (t == null ? void 0 : t.value) ?? "" : "").replace(e, "") || n.replace(e, "") || void 0, g = (n, t, o) => r(p("", o), p(p("", t) || "", n)), E = (n, t = [], o = []) => r([...o, ...t == null ? void 0 : t.map((C) => n ? `${n}--${C}` : C)]);
+import cx from "classnames";
+const EXCESS_WHITESPACE_CHAR = /^\s+|\s+(?=\s|$)/g;
+const parseClassName = (fallbackClassName, className) => {
+  const classes = className ? typeof className === "string" ? className : (className == null ? void 0 : className.value) ?? "" : "";
+  return classes.replace(EXCESS_WHITESPACE_CHAR, "") || fallbackClassName.replace(EXCESS_WHITESPACE_CHAR, "") || void 0;
+};
+const getClassName = (className, fallbackClassName, requiredClassName) => cx(parseClassName("", requiredClassName), parseClassName(parseClassName("", fallbackClassName) || "", className));
+const getModifierClasses = (prefix, modifiers = [], baseClasses = []) => cx([...baseClasses, ...modifiers == null ? void 0 : modifiers.map((m) => prefix ? `${prefix}--${m}` : m)]);
 export {
-  g as getClassName,
-  E as getModifierClasses,
-  p as parseClassName
+  getClassName,
+  getModifierClasses,
+  parseClassName
 };

package/dist/es/utils/common/constants.js

@@ -1,8 +1,12 @@
-const t = Object.create, e = () => !0, c = { defineProperty: e, set: e }, r = Object.freeze([]), n = Object.freeze(t(null));
+const $createObject = Object.create;
+const $true = () => true;
+const immutableProxyHandlers = { defineProperty: $true, set: $true };
+const EMPTY_ARRAY = Object.freeze([]);
+const EMPTY_OBJECT = Object.freeze($createObject(null));
 export {
-  t as $createObject,
-  e as $true,
-  r as EMPTY_ARRAY,
-  n as EMPTY_OBJECT,
-  c as immutableProxyHandlers
+  $createObject,
+  $true,
+  EMPTY_ARRAY,
+  EMPTY_OBJECT,
+  immutableProxyHandlers
 };

package/dist/es/utils/common/index.js

@@ -1,34 +1,61 @@
-import { $createObject as s, immutableProxyHandlers as c } from "./constants.js";
-import { $true as S, EMPTY_ARRAY as T, EMPTY_OBJECT as Y } from "./constants.js";
-const r = Function.prototype.bind.bind(Function.prototype.call), p = r(s, void 0, null), m = r(s, void 0), y = r(Object.prototype.toString), f = r(Object.prototype.hasOwnProperty), b = new Proxy(() => {
-}, c), d = (t, o = !1) => ({
-  writable: o === !0,
-  enumerable: !0,
-  value: t
-}), a = (t) => t, P = (t, o) => typeof t == "boolean" ? t : !!o, h = (t, o, n) => Math.max(t, Math.min(o, n)), x = (t, o) => t + Math.floor((o - t) / 2), F = (t, o) => (t % o + o) % o, M = (t) => typeof t == "function", e = (t) => typeof t == "number", O = (t) => e(t) && 1 / t === 0, u = (t) => e(t) && t === ~~t, g = (t, o) => t === o || !(t === t || o === o), j = (t, o, n) => t.includes(o) ? o : o == null ? t[0] : t.includes(n) ? n : t[0], w = (t) => t && typeof t != "boolean" && (t != null && t.value) ? !!(t != null && t.value) : !!t;
+import { $createObject, immutableProxyHandlers } from "./constants.js";
+import { $true, EMPTY_ARRAY, EMPTY_OBJECT } from "./constants.js";
+const call = Function.prototype.bind.bind(Function.prototype.call);
+const struct = call($createObject, void 0, null);
+const structFrom = call($createObject, void 0);
+const toString = call(Object.prototype.toString);
+const hasOwnProperty = call(Object.prototype.hasOwnProperty);
+const noop = new Proxy(() => {
+}, immutableProxyHandlers);
+const asyncNoop = async () => {
+};
+const enumerable = (value, writable = false) => ({
+  writable: writable === true,
+  enumerable: true,
+  value
+});
+const identity = (value) => value;
+const boolify = (value, fallbackBoolean) => typeof value === "boolean" ? value : !!fallbackBoolean;
+const clamp = (min, value, max) => Math.max(min, Math.min(value, max));
+const mid = (low, high) => low + Math.floor((high - low) / 2);
+const mod = (value, modulo) => (value % modulo + modulo) % modulo;
+const isFunction = (value) => typeof value === "function";
+const isNumber = (value) => typeof value === "number";
+const isInfinite = (value) => isNumber(value) && 1 / value === 0;
+const isBitSafeInteger = (value) => isNumber(value) && value === ~~value;
+const sameValue = (a, b) => a === b || !(a === a || b === b);
+const pickFromCollection = (collection, option, defaultOption) => {
+  if (collection.includes(option))
+    return option;
+  if (option == void 0)
+    return collection[0];
+  return collection.includes(defaultOption) ? defaultOption : collection[0];
+};
+const parseBoolean = (value) => value && typeof value !== "boolean" && (value == null ? void 0 : value.value) ? !!(value == null ? void 0 : value.value) : !!value;
 export {
-  s as $createObject,
-  S as $true,
-  T as EMPTY_ARRAY,
-  Y as EMPTY_OBJECT,
-  P as boolify,
-  r as call,
-  h as clamp,
-  d as enumerable,
-  f as hasOwnProperty,
-  a as identity,
-  c as immutableProxyHandlers,
-  u as isBitSafeInteger,
-  M as isFunction,
-  O as isInfinite,
-  e as isNumber,
-  x as mid,
-  F as mod,
-  b as noop,
-  w as parseBoolean,
-  j as pickFromCollection,
-  g as sameValue,
-  p as struct,
-  m as structFrom,
-  y as toString
+  $createObject,
+  $true,
+  EMPTY_ARRAY,
+  EMPTY_OBJECT,
+  asyncNoop,
+  boolify,
+  call,
+  clamp,
+  enumerable,
+  hasOwnProperty,
+  identity,
+  immutableProxyHandlers,
+  isBitSafeInteger,
+  isFunction,
+  isInfinite,
+  isNumber,
+  mid,
+  mod,
+  noop,
+  parseBoolean,
+  pickFromCollection,
+  sameValue,
+  struct,
+  structFrom,
+  toString
 };

package/dist/es/utils/fixedForwardRef.js

@@ -1,5 +1,5 @@
-import { forwardRef as f } from "../external/preact/compat/dist/compat.module.js";
-const o = (r) => f(r), a = o;
+import { k } from "../../compat.module-a4d537ff.mjs";
+const fixedForwardRef = (render) => k(render);
 export {
-  a as default
+  fixedForwardRef as default
 };

package/dist/es/utils/get-image.js

@@ -1,16 +1,17 @@
-import { FALLBACK_CONTEXT as m } from "../core/config.js";
-const n = ({ name: e, loadingContext: t, imageFolder: o = "", parentFolder: r = "", extension: g, size: a = "", subFolder: s = "" }) => `${t}images/${o}${s}${r}${e}${a}.${g}`, $ = ({ loadingContext: e = m, extension: t = "svg", ...o }) => (r) => {
-  const g = {
-    extension: t,
-    loadingContext: e,
+import { FALLBACK_CONTEXT } from "../core/config.js";
+const returnImage = ({ name, loadingContext, imageFolder = "", parentFolder = "", extension, size = "", subFolder = "" }) => `${loadingContext}images/${imageFolder}${subFolder}${parentFolder}${name}${size}.${extension}`;
+const getImageUrl = ({ loadingContext = FALLBACK_CONTEXT, extension = "svg", ...options }) => (name) => {
+  const imageOptions = {
+    extension,
+    loadingContext,
     imageFolder: "logos/",
     parentFolder: "",
-    name: r,
-    ...o
+    name,
+    ...options
   };
-  return n(g);
-}, l = $;
+  return returnImage(imageOptions);
+};
 export {
-  l as default,
-  $ as getImageUrl
+  getImageUrl as default,
+  getImageUrl
 };

package/dist/es/utils/get-image.test.js

@@ -0,0 +1,38 @@
+import { getImageUrl } from "./get-image.js";
+import { d as describe, t as test, g as globalExpect } from "../../vendor-vi.a3ff54b1-5e924357.mjs";
+describe("Ideal utils", () => {
+  describe("getImageUrl", () => {
+    const issuer = 123;
+    const loadingContext = "http://adyen.com/";
+    const type = "ideal";
+    test("Gets a full url with a parentContext", () => {
+      const options = {
+        loadingContext,
+        parentFolder: "ideal/"
+      };
+      globalExpect(getImageUrl(options)(issuer)).toBe("http://adyen.com/images/logos/ideal/123.svg");
+    });
+    test("Gets an image under components/ folder", () => {
+      const options = {
+        loadingContext,
+        imageFolder: "components/"
+      };
+      globalExpect(getImageUrl(options)("success")).toBe("http://adyen.com/images/components/success.svg");
+    });
+    test("Gets a full url without a parentContext (default ideal image)", () => {
+      const options = {
+        loadingContext,
+        parentFolder: ""
+      };
+      globalExpect(getImageUrl(options)(type)).toBe("http://adyen.com/images/logos/ideal.svg");
+    });
+    test("Gets an image in PNG", () => {
+      const options = {
+        loadingContext,
+        parentFolder: "ideal/",
+        extension: "png"
+      };
+      globalExpect(getImageUrl(options)(issuer)).toBe("http://adyen.com/images/logos/ideal/123.png");
+    });
+  });
+});

package/dist/es/utils/idGenerator.js

@@ -1,5 +1,8 @@
-let e = Date.now();
-const n = (t = "field") => (e += 1, `${t}-${e}`);
+let idCounter = Date.now();
+const getUniqueId = (prefix = "field") => {
+  idCounter += 1;
+  return `${prefix}-${idCounter}`;
+};
 export {
-  n as getUniqueId
+  getUniqueId
 };

package/dist/es/utils/memoComparator/index.js

@@ -0,0 +1,4 @@
+import { default as default2 } from "./memoComparator.js";
+export {
+  default2 as default
+};

package/dist/es/utils/memoComparator/memoComparator.js

@@ -1,23 +1,32 @@
-import { noop as i, sameValue as m, isFunction as u, identity as f } from "../common/index.js";
-const d = (() => {
-  const t = /* @__PURE__ */ new Set(), c = (e, a, r, o) => {
-    let n = o == null ? void 0 : o[r];
-    return n = u(n) ? n : f, !m(n(e[r]), n(a[r]));
+import { noop, sameValue, isFunction, identity } from "../common/index.js";
+const memoComparator = (() => {
+  const _comparedProps = /* @__PURE__ */ new Set();
+  const _propHasChanged = (prev, next, prop, getters) => {
+    let getter = getters == null ? void 0 : getters[prop];
+    getter = isFunction(getter) ? getter : identity;
+    return !sameValue(getter(prev[prop]), getter(next[prop]));
   };
-  return Object.defineProperty((e) => (a, r) => {
+  const comparator = (getters) => (prev, next) => {
     try {
-      for (const o in a)
-        if (t.add(o), c(a, r, o, e))
-          return !1;
-      for (const o in r)
-        if (!t.has(o) && (t.add(o), c(a, r, o, e)))
-          return !1;
-      return !0;
+      for (const prop in prev) {
+        _comparedProps.add(prop);
+        if (_propHasChanged(prev, next, prop, getters))
+          return false;
+      }
+      for (const prop in next) {
+        if (_comparedProps.has(prop))
+          continue;
+        _comparedProps.add(prop);
+        if (_propHasChanged(prev, next, prop, getters))
+          return false;
+      }
+      return true;
     } finally {
-      t.clear();
+      _comparedProps.clear();
     }
-  }, "exclude", { value: i });
-})(), s = d;
+  };
+  return Object.defineProperty(comparator, "exclude", { value: noop });
+})();
 export {
-  s as default
+  memoComparator as default
 };

package/dist/es/utils/regex.js

@@ -0,0 +1,6 @@
+const email = /^\s*[\w\-+_]+(\.[\w\-+_]+)*@[\w\-+_]+\.[\w\-+_]+(\.[\w-+_]+)*\s*$/;
+const telephoneNumber = /^[+]*[(]{0,1}[0-9]{1,3}[)]{0,1}[-\s./0-9]*$/;
+export {
+  email,
+  telephoneNumber
+};

package/dist/es/utils/tabbable.js

@@ -1,5 +1,5 @@
-import { isNumber as v, mod as R } from "./common/index.js";
-const p = `
+import { isNumber, mod } from "./common/index.js";
+const SELECTORS = `
     a[href],
     audio[controls],
     video[controls],
@@ -9,35 +9,51 @@ const p = `
     textarea,
     [contenteditable],
     [tabindex]
-`.replace(/\s+/, ""), b = ["contenteditable", "controls", "disabled", "hidden", "href", "inert", "tabindex"], f = /* @__PURE__ */ new Map(), l = Function.prototype.call.bind(Array.prototype.some), h = (t) => t.tagName === "INPUT", x = (t) => h(t) && t.type === "radio", E = (t) => {
-  const n = t.name, r = t.form, o = f.get(r);
-  let i = o == null ? void 0 : o.get(n);
-  return i === void 0 && r && (i = r.querySelector(`input[type=radio][name='${n}']:checked`) || null, f.set(r, (o || /* @__PURE__ */ new Map()).set(n, i))), i === t;
-}, I = (t, n) => {
-  for (const r of n)
-    if (r.type !== "attributes") {
-      if (l(r.addedNodes, (o) => o instanceof Element && s(o)) || l(r.removedNodes, (o) => t.includes(o)))
-        return !0;
-    } else {
-      if (s(r.target))
-        return !0;
-      if (t.includes(r.target))
-        return !0;
-    }
-  return !1;
-}, g = (t = document.body, n) => {
-  if (t === void 0)
-    return !1;
-  if (n == null)
-    return !!document.activeElement && g(t, document.activeElement);
-  let r = n == null ? void 0 : n.parentNode;
-  for (; r; ) {
-    if (r === t)
-      return !0;
-    r = r == null ? void 0 : r.parentNode;
+`.replace(/\s+/, "");
+const ATTRIBUTES = ["contenteditable", "controls", "disabled", "hidden", "href", "inert", "tabindex"];
+const CHECKED_RADIOS = /* @__PURE__ */ new Map();
+const some = Function.prototype.call.bind(Array.prototype.some);
+const isInput = (element) => element.tagName === "INPUT";
+const isRadio = (element) => isInput(element) && element.type === "radio";
+const isCheckedRadio = (element) => {
+  const name = element.name;
+  const form = element.form;
+  const checkedRadiosForForm = CHECKED_RADIOS.get(form);
+  let checkedRadio = checkedRadiosForForm == null ? void 0 : checkedRadiosForForm.get(name);
+  if (checkedRadio === void 0 && form) {
+    checkedRadio = form.querySelector(`input[type=radio][name='${name}']:checked`) || null;
+    CHECKED_RADIOS.set(form, (checkedRadiosForForm || /* @__PURE__ */ new Map()).set(name, checkedRadio));
   }
-  return !1;
-}, N = (t) => !// [TODO]: Include all of these checks
+  return checkedRadio === element;
+};
+const shouldRefresh = (tabbables, records) => {
+  for (const record of records) {
+    if (record.type !== "attributes") {
+      if (some(record.addedNodes, (node) => node instanceof Element && isTabbable(node)))
+        return true;
+      if (some(record.removedNodes, (node) => tabbables.includes(node)))
+        return true;
+    } else if (isTabbable(record.target))
+      return true;
+    else if (tabbables.includes(record.target))
+      return true;
+  }
+  return false;
+};
+const focusIsWithin = (rootElement = document.body, elementWithFocus) => {
+  if (rootElement === void 0)
+    return false;
+  if (elementWithFocus == void 0)
+    return !!document.activeElement && focusIsWithin(rootElement, document.activeElement);
+  let parentElement = elementWithFocus == null ? void 0 : elementWithFocus.parentNode;
+  while (parentElement) {
+    if (parentElement === rootElement)
+      return true;
+    parentElement = parentElement == null ? void 0 : parentElement.parentNode;
+  }
+  return false;
+};
+const isFocusable = (element) => !// [TODO]: Include all of these checks
 // (1) matches focusable elements selector
 // (2) is disabled element
 // (3) is inert or inert subtree child
@@ -47,54 +63,77 @@ const p = `
 // (7) is details with summary element
 // (8) is disabled fieldset subtree child
 /* (1) */
-(!t.matches(p) || /* (2) */
-t != null && t.disabled || /* (3) */
-/^(true)?$/.test(t.getAttribute("inert")) || /* (4) */
-h(t) && t.hidden), s = (t) => !(x(t) && !E(t) || // (1) is not checked radio button
-(t == null ? void 0 : t.tabIndex) < 0 || // (2) has negative tabindex
-!N(t)), S = () => {
-  const t = new MutationObserver((e) => I(n, e) && u()), n = [];
-  let r = -1, o = null;
-  const i = (e) => {
-    var a;
-    if (e < 0)
+(!element.matches(SELECTORS) || /* (2) */
+(element == null ? void 0 : element.disabled) || /* (3) */
+/^(true)?$/.test(element.getAttribute("inert")) || /* (4) */
+isInput(element) && element.hidden);
+const isTabbable = (element) => !(isRadio(element) && !isCheckedRadio(element) || // (1) is not checked radio button
+(element == null ? void 0 : element.tabIndex) < 0 || // (2) has negative tabindex
+!isFocusable(element));
+const withTabbableRoot = () => {
+  const observer = new MutationObserver((records) => shouldRefresh(tabbables, records) && getTabbables());
+  const tabbables = [];
+  let currentIndex = -1;
+  let root = null;
+  const focusAt = (tabbableIndex) => {
+    var _a;
+    if (tabbableIndex < 0)
+      return;
+    const constrainedIndex = Math.min(tabbableIndex, tabbables.length - 1);
+    if (currentIndex !== constrainedIndex)
+      currentIndex = constrainedIndex;
+    (_a = tabbables[currentIndex]) == null ? void 0 : _a.focus();
+  };
+  const getTabbables = () => {
+    tabbables.length = 0;
+    if (!(root instanceof Element))
+      return;
+    root.querySelectorAll(SELECTORS).forEach((maybeTabbable) => isTabbable(maybeTabbable) && tabbables.push(maybeTabbable));
+    if (!focusIsWithin(root))
       return;
-    const d = Math.min(e, n.length - 1);
-    r !== d && (r = d), (a = n[r]) == null || a.focus();
-  }, u = () => {
-    n.length = 0, o instanceof Element && (o.querySelectorAll(p).forEach((e) => s(e) && n.push(e)), g(o) && (c.current = document.activeElement));
-  }, c = Object.create(null, {
+    tabbableRoot.current = document.activeElement;
+  };
+  const tabbableRoot = Object.create(null, {
     current: {
-      get: () => n[r] ?? null,
-      set: (e) => {
-        if (e) {
-          if (!v(e))
-            return i(n.indexOf(e));
-          if (e === ~~e)
-            return i(R(r + e, n.length));
-        }
+      get: () => tabbables[currentIndex] ?? null,
+      set: (maybeTabbableOrOffset) => {
+        if (!maybeTabbableOrOffset)
+          return;
+        if (!isNumber(maybeTabbableOrOffset))
+          return focusAt(tabbables.indexOf(maybeTabbableOrOffset));
+        if (maybeTabbableOrOffset !== ~~maybeTabbableOrOffset)
+          return;
+        return focusAt(mod(currentIndex + maybeTabbableOrOffset, tabbables.length));
       }
     },
     root: {
-      get: () => o,
-      set: (e) => {
-        e !== o && (o && t.disconnect(), o = e instanceof Element ? e : null, n.length = 0, o && (t.observe(o, {
-          attributeFilter: b,
-          attributes: !0,
-          childList: !0,
-          subtree: !0
-        }), u()));
+      get: () => root,
+      set: (maybeElement) => {
+        if (maybeElement === root)
+          return;
+        root && observer.disconnect();
+        root = maybeElement instanceof Element ? maybeElement : null;
+        tabbables.length = 0;
+        if (!root)
+          return;
+        observer.observe(root, {
+          attributeFilter: ATTRIBUTES,
+          attributes: true,
+          childList: true,
+          subtree: true
+        });
+        getTabbables();
       }
     },
-    tabbables: { value: n }
+    tabbables: { value: tabbables }
   });
-  return c;
+  return tabbableRoot;
 };
 export {
-  p as SELECTORS,
-  S as default,
-  g as focusIsWithin,
-  N as isFocusable,
-  s as isTabbable,
-  S as withTabbableRoot
+  SELECTORS,
+  withTabbableRoot as default,
+  focusIsWithin,
+  isFocusable,
+  isTabbable,
+  withTabbableRoot
 };

package/dist/es/utils/useForm/index.js

@@ -0,0 +1,4 @@
+import { default as default2 } from "./useForm.js";
+export {
+  default2 as default
+};