@adyen/adyen-platform-experience-web 0.1.2 → 1.0.0-beta.1

package/dist/es/hooks/useReflex/core/registry.test.js

@@ -0,0 +1,114 @@
+import { REF } from "../constants.js";
+import { createReflexRegister } from "./registry.js";
+import { isReflex } from "./utils.js";
+import { d as describe, b as beforeEach, t as test, g as globalExpect, v as vi } from "../../../../vendor-vi.a3ff54b1-5e924357.mjs";
+describe("createReflexRegister", () => {
+  beforeEach((context) => {
+    context.action = vi.fn(() => {
+    });
+    context.ref = { current: 5 };
+    context.register = createReflexRegister();
+  });
+  test("should throw error if reflex action is missing for unregistered ref", ({ ref, register }) => {
+    globalExpect(() => register.bind(ref)).toThrowError();
+  });
+  test("should throw error if trying to unbind action for unregistered ref", ({ action, ref, register }) => {
+    globalExpect(() => register.unbind(ref, action)).toThrowError();
+    const { actions } = register.bind(ref, action);
+    globalExpect(actions.size).toBe(1);
+    globalExpect(actions.get(action)).toBe(1);
+    register.unbind(ref, action);
+    globalExpect(actions.size).toBe(0);
+    globalExpect(actions.get(action)).toBeUndefined;
+    globalExpect(() => register.unbind(ref, action)).toThrowError();
+  });
+  test("should register unknown ref if reflex action is provided", ({ action, ref, register }) => {
+    const reflex = register.bind(ref, action);
+    const { actions } = reflex;
+    globalExpect(isReflex(reflex)).toBe(true);
+    globalExpect(reflex.current).toBe(ref.current);
+    globalExpect(reflex[REF]).toBe(ref);
+    globalExpect(actions.size).toBe(1);
+    globalExpect(actions.get(action)).toBe(1);
+    globalExpect(action).toBeCalledTimes(0);
+    let previous = ref.current;
+    reflex.current = 10;
+    globalExpect(ref.current).toBe(10);
+    globalExpect(ref.current).toBe(reflex.current);
+    globalExpect(action).toBeCalledWith(10, previous);
+    globalExpect(action).toBeCalledTimes(1);
+    reflex.current = previous = ref.current;
+    globalExpect(ref.current).toBe(previous);
+    globalExpect(ref.current).toBe(reflex.current);
+    globalExpect(action).toBeCalledTimes(1);
+    reflex(5);
+    globalExpect(ref.current).toBe(5);
+    globalExpect(ref.current).toBe(reflex.current);
+    globalExpect(action).toBeCalledWith(5, previous);
+    globalExpect(action).toBeCalledTimes(2);
+    reflex(previous = ref.current);
+    globalExpect(ref.current).toBe(previous);
+    globalExpect(ref.current).toBe(reflex.current);
+    globalExpect(action).toBeCalledTimes(2);
+  });
+  test("should increase and decrease binding count for reflex action", ({ action, ref, register }) => {
+    let { actions } = register.bind(ref, action);
+    globalExpect(actions.size).toBe(1);
+    globalExpect(actions.get(action)).toBe(1);
+    ({ actions } = register.bind(ref, action));
+    globalExpect(actions.size).toBe(1);
+    globalExpect(actions.get(action)).toBe(2);
+    register.bind(ref, action);
+    register.bind(ref, action);
+    register.bind(ref, console.log);
+    globalExpect(actions.size).toBe(2);
+    globalExpect(actions.get(action)).toBe(4);
+    globalExpect(actions.get(console.log)).toBe(1);
+    register.unbind(ref, action);
+    register.unbind(ref, action);
+    register.unbind(ref, action);
+    globalExpect(actions.size).toBe(2);
+    globalExpect(actions.get(action)).toBe(1);
+    register.unbind(ref, action);
+    register.bind(ref, console.log);
+    globalExpect(actions.size).toBe(1);
+    globalExpect(actions.get(action)).toBeUndefined;
+    globalExpect(actions.get(console.log)).toBe(2);
+    register.unbind(ref, console.log);
+    register.unbind(ref, console.log);
+    globalExpect(actions.size).toBe(0);
+    globalExpect(actions.get(console.log)).toBeUndefined;
+    globalExpect(() => register.bind(ref)).toThrowError();
+  });
+  test("should trigger reflex action once regardless of binding count", ({ action, ref, register }) => {
+    register.bind(ref, action);
+    register.bind(ref, action);
+    register.bind(ref, action);
+    const reflex = register.bind(ref);
+    const { actions } = reflex;
+    globalExpect(actions.size).toBe(1);
+    globalExpect(actions.get(action)).toBe(3);
+    let previous = ref.current;
+    reflex.current = 10;
+    globalExpect(action).toBeCalledWith(10, previous);
+    globalExpect(action).toBeCalledTimes(1);
+    globalExpect(actions.get(action)).toBe(3);
+    previous = ref.current;
+    reflex(5);
+    globalExpect(action).toBeCalledWith(5, previous);
+    globalExpect(action).toBeCalledTimes(2);
+    globalExpect(actions.get(action)).toBe(3);
+    register.unbind(ref, action);
+    register.unbind(ref, action);
+    register.unbind(ref, action);
+    previous = ref.current;
+    reflex(10);
+    globalExpect(ref.current).not.toBe(10);
+    globalExpect(ref.current).toBe(previous);
+    globalExpect(ref.current).toBe(reflex.current);
+    globalExpect(actions.size).toBe(0);
+    globalExpect(action).toBeCalledTimes(2);
+    globalExpect(actions.get(action)).toBeUndefined;
+    globalExpect(() => register.bind(ref)).toThrowError();
+  });
+});

package/dist/es/hooks/useReflex/core/utils.js

@@ -1,23 +1,25 @@
-import { REF as o } from "../constants.js";
-import { MissingReflexActionError as c } from "../errors.js";
-import { isFunction as i, hasOwnProperty as n, sameValue as e } from "../../../utils/common/index.js";
-import { EMPTY_OBJECT as f } from "../../../utils/common/constants.js";
-function h(t) {
-  if (!i(t))
-    throw new c();
+import { REF } from "../constants.js";
+import { MissingReflexActionError } from "../errors.js";
+import { isFunction, hasOwnProperty, sameValue } from "../../../utils/common/index.js";
+import { EMPTY_OBJECT } from "../../../utils/common/constants.js";
+function assertReflexAction(value) {
+  if (!isFunction(value))
+    throw new MissingReflexActionError();
 }
-const m = (t) => {
+const isReflex = (value) => {
   try {
-    if (i(t) && n(t, "current") && n(t, o) && !e(t, t[o])) {
-      const s = t.actions.get(f), r = t.actions.size;
-      return s === void 0 && Number.isInteger(r) && r >= 0;
+    if (isFunction(value) && hasOwnProperty(value, "current") && hasOwnProperty(value, REF) && !sameValue(value, value[REF])) {
+      const notDefined = value.actions.get(EMPTY_OBJECT);
+      const size = value.actions.size;
+      return notDefined === void 0 && Number.isInteger(size) && size >= 0;
     }
   } catch {
   }
-  return !1;
-}, p = (t) => m(t) ? p(t[o]) : t;
+  return false;
+};
+const unwrap = (reflexable) => isReflex(reflexable) ? unwrap(reflexable[REF]) : reflexable;
 export {
-  h as assertReflexAction,
-  m as isReflex,
-  p as unwrap
+  assertReflexAction,
+  isReflex,
+  unwrap
 };

package/dist/es/hooks/useReflex/core/utils.test.js

@@ -0,0 +1,59 @@
+import { REF } from "../constants.js";
+import { assertReflexAction, isReflex, unwrap } from "./utils.js";
+import { d as describe, t as test, g as globalExpect } from "../../../../vendor-vi.a3ff54b1-5e924357.mjs";
+describe("assertReflexAction", () => {
+  test("should throw for non-callable", () => {
+    globalExpect(() => assertReflexAction()).toThrowError();
+    globalExpect(() => assertReflexAction({})).toThrowError();
+    globalExpect(() => assertReflexAction([])).toThrowError();
+    globalExpect(() => assertReflexAction(null)).toThrowError();
+    globalExpect(() => assertReflexAction("hello")).toThrowError();
+  });
+  test("should not throw for callable", () => {
+    globalExpect(() => assertReflexAction(() => {
+    })).not.toThrowError();
+  });
+});
+describe("isReflex", () => {
+  test("should return false for refs", () => {
+    const refObject = { current: 5 };
+    const refCallback = () => {
+    };
+    globalExpect(isReflex(refObject)).toBe(false);
+    globalExpect(isReflex(refCallback)).toBe(false);
+  });
+  test("should return true for only true reflexes", () => {
+    let reflex = {};
+    globalExpect(isReflex(reflex)).toBe(false);
+    reflex = () => {
+    };
+    globalExpect(isReflex(reflex)).toBe(false);
+    reflex[REF] = { current: 5 };
+    globalExpect(isReflex(reflex)).toBe(false);
+    reflex.current = reflex[REF].current;
+    globalExpect(isReflex(reflex)).toBe(false);
+    reflex.actions = /* @__PURE__ */ new Map();
+    globalExpect(isReflex(reflex)).toBe(true);
+    reflex[REF] = reflex;
+    globalExpect(isReflex(reflex)).toBe(false);
+  });
+});
+describe("unwrap", () => {
+  test("should return refs (the same)", () => {
+    const refObject = { current: 5 };
+    const refCallback = () => {
+    };
+    globalExpect(unwrap(refObject)).toBe(refObject);
+    globalExpect(unwrap(refCallback)).toBe(refCallback);
+  });
+  test("should return root ref for true reflexes", () => {
+    const _ref = { current: 5 };
+    const reflex = () => {
+    };
+    reflex[REF] = _ref;
+    reflex.current = reflex[REF].current;
+    reflex.actions = /* @__PURE__ */ new Map();
+    globalExpect(unwrap(reflex)).toBe(_ref);
+    globalExpect(unwrap(reflex).current).toBe(_ref.current);
+  });
+});

package/dist/es/hooks/useReflex/errors.js

@@ -1,11 +1,11 @@
-class e extends Error {
+class ReflexError extends Error {
 }
-class s extends e {
+class UnknownRefError extends ReflexError {
 }
-class n extends e {
+class MissingReflexActionError extends ReflexError {
 }
 export {
-  n as MissingReflexActionError,
-  e as ReflexError,
-  s as UnknownRefError
+  MissingReflexActionError,
+  ReflexError,
+  UnknownRefError
 };

package/dist/es/hooks/useReflex/hooks/useReflex.js

@@ -1,9 +1,14 @@
-import { useRef as s, useLayoutEffect as u, useMemo as n } from "../../../external/preact/hooks/dist/hooks.module.js";
-import { createReflexContainer as o } from "../core/reflex.js";
-const a = (r, t) => {
-  const e = s(o());
-  return u(() => e.current.release, []), n(() => (e.current.update(r, t), e.current.reflex), [r, t]);
-}, m = a;
+import { _, y, F } from "../../../../hooks.module-8565d716.mjs";
+import { createReflexContainer } from "../core/reflex.js";
+import "../errors.js";
+const useReflex = (action, reflexable) => {
+  const container = _(createReflexContainer());
+  y(() => container.current.release, []);
+  return F(() => {
+    container.current.update(action, reflexable);
+    return container.current.reflex;
+  }, [action, reflexable]);
+};
 export {
-  m as default
+  useReflex as default
 };

package/dist/es/hooks/useReflex/index.js

@@ -0,0 +1,8 @@
+import { default as default2 } from "./hooks/useReflex.js";
+import { MissingReflexActionError, ReflexError, UnknownRefError } from "./errors.js";
+export {
+  MissingReflexActionError,
+  ReflexError,
+  UnknownRefError,
+  default2 as default
+};

package/dist/es/hooks/useSessionAwareRequest/useSessionAwareRequest.js

@@ -1,27 +1,44 @@
-import u from "../../core/Auth/useAuthContext.js";
-import { http as s } from "../../core/Services/requests/http.js";
-import { ErrorTypes as m } from "../../core/Services/requests/utils.js";
-import { useMemo as c } from "../../external/preact/hooks/dist/hooks.module.js";
-import { EMPTY_OBJECT as f } from "../../utils/common/constants.js";
-const h = (() => {
-  let r, t;
-  return (a) => (a !== r && (r = a, t = (e, o, n) => s({ ...e, headers: { ...e.headers, Authorization: `Bearer ${r}` }, method: o }, n)), t);
+import useAuthContext from "../../core/Auth/useAuthContext.js";
+import { http } from "../../core/Services/requests/http.js";
+import { ErrorTypes } from "../../core/Services/requests/utils.js";
+import { noop } from "../../utils/common/index.js";
+import { _, F } from "../../../hooks.module-8565d716.mjs";
+const getHttpCaller = (() => {
+  let token;
+  let caller;
+  return (sessionToken) => {
+    if (sessionToken !== token) {
+      token = sessionToken;
+      caller = (request, method, data) => http({ ...request, headers: { ...request.headers, Authorization: `Bearer ${token}` }, method }, data);
+    }
+    return caller;
+  };
 })();
-function A() {
-  const { token: r, updateCore: t } = u();
-  return { httpProvider: c(() => {
-    const e = h(r);
-    return async (o, n, i) => {
+function useSessionAwareRequest() {
+  const { token, updateCore, isUpdatingToken } = useAuthContext();
+  const cachedResolve = _(noop);
+  const httpProvider = F(() => {
+    let resolve = noop;
+    const promise = new Promise((_resolve) => {
+      resolve = _resolve;
+    });
+    cachedResolve.current(promise);
+    cachedResolve.current = resolve;
+    const httpCall = getHttpCaller(token);
+    return async (request, method, data) => {
       try {
-        return await e(o, n, i);
-      } catch (p) {
-        if (p.type === m.EXPIRED_TOKEN)
-          return await (t == null ? void 0 : t(f, !0)), e(o, n, i);
-        throw p;
+        return await (isUpdatingToken ? promise : Promise.resolve()).then(() => httpCall({ ...request }, method, data));
+      } catch (e) {
+        if (e.type === ErrorTypes.EXPIRED_TOKEN && !isUpdatingToken) {
+          await updateCore();
+          resolve(token);
+        }
+        throw e;
       }
     };
-  }, [r, t]) };
+  }, [token, updateCore, isUpdatingToken]);
+  return { httpProvider };
 }
 export {
-  A as default
+  useSessionAwareRequest as default
 };

package/dist/es/hooks/useSetupEndpoint/useSetupEndpoint.js

@@ -1,27 +1,33 @@
-import i from "../../core/Auth/useAuthContext.js";
-import h from "../useSessionAwareRequest/useSessionAwareRequest.js";
-import f from "../../core/Context/useCoreContext.js";
-import { parseSearchParams as l } from "../../core/Services/requests/utils.js";
-import { useCallback as C } from "../../external/preact/hooks/dist/hooks.module.js";
-import { EMPTY_OBJECT as y } from "../../utils/common/constants.js";
-const O = (e) => {
-  const { endpoints: s } = i(), { loadingContext: a } = f(), { httpProvider: n } = h();
-  return C(
-    async (...p) => {
-      const u = p[0], t = p[1] || y, m = s[e], o = t.path;
-      let r = m.url;
-      if (o) {
-        const c = Object.keys(o)[0];
-        r = r.replace(`{${c}}`, o[c]);
+import useAuthContext from "../../core/Auth/useAuthContext.js";
+import useSessionAwareRequest from "../useSessionAwareRequest/useSessionAwareRequest.js";
+import useCoreContext from "../../core/Context/useCoreContext.js";
+import { parseSearchParams } from "../../core/Services/requests/utils.js";
+import { T } from "../../../hooks.module-8565d716.mjs";
+import "../../utils/common/index.js";
+import { EMPTY_OBJECT } from "../../utils/common/constants.js";
+const useSetupEndpoint = (endpoint) => {
+  const { endpoints } = useAuthContext();
+  const { loadingContext } = useCoreContext();
+  const { httpProvider } = useSessionAwareRequest();
+  return T(
+    async (...args) => {
+      const requestOptions = args[0];
+      const params = args[1] || EMPTY_OBJECT;
+      const operation = endpoints[endpoint];
+      const pathParam = params.path;
+      let path = operation.url;
+      if (pathParam) {
+        const pathParamKey = Object.keys(pathParam)[0];
+        path = path.replace(`{${pathParamKey}}`, pathParam[pathParamKey]);
       }
-      return n(
-        { loadingContext: a, path: r, ...u, params: t.query && l(t.query) },
-        m.method ?? "GET"
+      return httpProvider(
+        { loadingContext, path, ...requestOptions, params: params.query && parseSearchParams(params.query) },
+        operation.method ?? "GET"
       );
     },
-    [e, s, n, a]
+    [endpoint, endpoints, httpProvider, loadingContext]
   );
 };
 export {
-  O as useSetupEndpoint
+  useSetupEndpoint
 };

package/dist/es/index.js

@@ -1,44 +1,48 @@
-import "./components/shared.scss.js";
-import "./style/index.scss.js";
-import o from "./core/core.js";
-import { all_locales as l, ar as p, cs_CZ as c, da_DK as f, de_DE as m, el_GR as R, en_US as u, es_ES as T, fi_FI as d, fr_FR as x, hr_HR as P, hu_HU as S, it_IT as h, ja_JP as C, ko_KR as F, nl_NL as z, no_NO as D, pl_PL as E, pt_BR as I, pt_PT as K, ro_RO as N, ru_RU as U, sk_SK as k, sl_SI as w, sv_SE as y, zh_CN as H, zh_TW as L } from "./core/Localization/translations/index.js";
-import { default as j } from "./components/external/Transactions/TransactionsOverviewElement.js";
-import { TransactionFilterParam as A } from "./components/external/Transactions/types.js";
-import { default as G } from "./components/external/TransactionDetails/TransactionDetails.js";
-async function n(r) {
-  return await new o(r).initialize();
+import Core from "./core/core.js";
+import "./core/Localization/datetime/restamper/restamper.js";
+import "./core/Localization/datetime/restamper/constants.js";
+import "./utils/common/index.js";
+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 "./core/Localization/translations/index.js";
+import "./utils/watchable/index.js";
+import "./components/index.js";
+import { TransactionsElement } from "./components/external/TransactionsOverview/TransactionsOverviewElement.js";
+import { T } from "../types-deec0d78.mjs";
+import { TransactionsElement as TransactionsElement2 } from "./components/external/TransactionDetails/TransactionDetails.js";
+async function AdyenPlatformExperience(props) {
+  const core = new Core(props);
+  return await core.initialize();
 }
 export {
-  n as AdyenFP,
-  o as Core,
-  A as TransactionFilterParam,
-  j as TransactionsComponent,
-  G as TransactionsDetails,
-  l as all_locales,
-  p as ar,
-  c as cs_CZ,
-  f as da_DK,
-  m as de_DE,
-  R as el_GR,
-  u as en_US,
-  T as es_ES,
-  d as fi_FI,
-  x as fr_FR,
-  P as hr_HR,
-  S as hu_HU,
-  h as it_IT,
-  C as ja_JP,
-  F as ko_KR,
-  z as nl_NL,
-  D as no_NO,
-  E as pl_PL,
-  I as pt_BR,
-  K as pt_PT,
-  N as ro_RO,
-  U as ru_RU,
-  k as sk_SK,
-  w as sl_SI,
-  y as sv_SE,
-  H as zh_CN,
-  L as zh_TW
+  AdyenPlatformExperience,
+  Core,
+  T as TransactionFilterParam,
+  TransactionsElement2 as TransactionsDetails,
+  TransactionsElement as TransactionsOverview,
+  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
 };

package/dist/es/utils/Storage.js

@@ -1,31 +1,35 @@
-var o = Object.defineProperty;
-var a = (r, t, e) => t in r ? o(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
-var s = (r, t, e) => (a(r, typeof t != "symbol" ? t + "" : t, e), e);
-class i {
-  constructor(t, e = window.localStorage) {
-    s(this, "prefix", "adyen-fp-");
-    s(this, "key");
-    s(this, "storage");
-    this.storage = e, this.key = this.prefix + t;
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class Storage {
+  constructor(key, storage = window.localStorage) {
+    __publicField(this, "prefix", "adyen-pe-");
+    __publicField(this, "key");
+    __publicField(this, "storage");
+    this.storage = storage;
+    this.key = this.prefix + key;
   }
   get() {
-    const t = this.storage.getItem(this.key);
-    if (t)
+    const storageItem = this.storage.getItem(this.key);
+    if (storageItem) {
       try {
-        return JSON.parse(t);
-      } catch {
+        return JSON.parse(storageItem);
+      } catch (err) {
         return null;
       }
+    }
     return null;
   }
-  set(t) {
-    this.storage.setItem(this.key, JSON.stringify(t));
+  set(value) {
+    this.storage.setItem(this.key, JSON.stringify(value));
   }
   remove() {
     this.storage.removeItem(this.key);
   }
 }
-const n = i;
 export {
-  n as default
+  Storage as default
 };

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

@@ -0,0 +1,28 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class ValidationRuleResult {
+  constructor(rule, value, mode, context) {
+    __publicField(this, "shouldValidate");
+    __publicField(this, "isValid");
+    __publicField(this, "errorMessage");
+    this.shouldValidate = mode ? rule.modes.includes(mode) : false;
+    this.isValid = rule.validate(value, context);
+    this.errorMessage = rule.errorMessage ?? "";
+  }
+  /**
+   * Whether the validation is considered an error.
+   * A field is only considered to be an error if the validation rule applies to the current mode i.e. 'blur' or 'input'.
+   * Also, if a validation function returns a null value e.g. when the field is empty, then the field will not be considered to be in error
+   * unless the whole form is being validated
+   */
+  hasError(isValidatingForm = false) {
+    return isValidatingForm ? !this.isValid && this.shouldValidate : this.isValid != null && !this.isValid && this.shouldValidate;
+  }
+}
+export {
+  ValidationRuleResult
+};

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

@@ -0,0 +1,67 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { ValidationRuleResult } from "./ValidationRuleResult.js";
+class ValidationResult {
+  constructor(results) {
+    __publicField(this, "validationResults");
+    this.validationResults = results;
+  }
+  /** Checks if all validation rules have passed */
+  get isValid() {
+    return this.validationResults.reduce((acc, result) => acc && result.isValid, true);
+  }
+  /** Checks if any validation rule returned an error */
+  hasError(isValidatingForm = false) {
+    return Boolean(this.getError(isValidatingForm));
+  }
+  /** Returns the first validation result that returned an error */
+  getError(isValidatingForm = false) {
+    return this.validationResults.find((result) => result.hasError(isValidatingForm));
+  }
+  /** Returns all validation results that returned an error */
+  getAllErrors() {
+    return this.validationResults.filter((result) => result.hasError());
+  }
+}
+class Validator {
+  constructor(rules) {
+    __publicField(this, "rules", {
+      default: {
+        validate: () => true,
+        modes: ["blur", "input"]
+      }
+    });
+    this.setRules(rules);
+  }
+  setRules(newRules) {
+    this.rules = {
+      ...this.rules,
+      ...newRules
+    };
+  }
+  /**
+   * Get all validation rules for a field
+   */
+  getRulesFor(field) {
+    let fieldRules = this.rules[field] ?? this.rules["default"];
+    if (!Array.isArray(fieldRules)) {
+      fieldRules = [fieldRules];
+    }
+    return fieldRules;
+  }
+  /**
+   * Validates a field
+   */
+  validate({ key, value, mode = "blur" }, context) {
+    const fieldRules = this.getRulesFor(key);
+    const validationRulesResult = fieldRules.map((rule) => new ValidationRuleResult(rule, value, mode, context));
+    return new ValidationResult(validationRulesResult);
+  }
+}
+export {
+  Validator as default
+};

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

@@ -0,0 +1,27 @@
+import Validator from "./Validator.js";
+import { d as describe, t as test, g as globalExpect } from "../../../vendor-vi.a3ff54b1-5e924357.mjs";
+const mockRules = {};
+describe("Validator", () => {
+  test("Fields are valid by default", () => {
+    const validator = new Validator(mockRules);
+    globalExpect(validator.validate({ key: "aNewField", value: "123" }).hasError()).toBe(false);
+    globalExpect(validator.validate({ key: "aNewField", value: "123", mode: "input" }).hasError()).toBe(false);
+  });
+  test("Set custom rules", () => {
+    const validator = new Validator({
+      aNewField: {
+        validate: () => false,
+        errorMessage: "test",
+        modes: ["blur"]
+      }
+    });
+    globalExpect(validator.validate({ key: "aNewField", value: "123" }).hasError()).toBe(true);
+    globalExpect(validator.validate({ key: "aNewField", value: "123", mode: "input" }).hasError()).toBe(false);
+  });
+  test("Has default rules", () => {
+    const validator = new Validator({});
+    globalExpect(validator.validate({ key: "aNewField", value: "123" }).hasError()).toBe(false);
+    globalExpect(validator.validate({ key: "aNewField", value: null }).hasError()).toBe(false);
+    globalExpect(validator.validate({ key: "shopperEmail", value: "test@test.com" }).hasError()).toBe(false);
+  });
+});