@adyen/adyen-platform-experience-web 1.10.2 → 1.11.0

package/dist/es/external/.pnpm/@adyen_kyc-components@4.0.0-compact.9_react@19.2.0_typescript@5.8.3/node_modules/@adyen/kyc-components/dist/useForm-BQDytQRR.js

@@ -0,0 +1,499 @@
+import { useMemo as I, useCallback as V, useReducer as G, useEffect as C, useState as H } from "../../../../../preact@10.29.0/node_modules/preact/hooks/dist/hooks.module.js";
+import { m as Q, b2 as W, ax as X } from "./StoreProvider-CBB99upB.js";
+import { V as j, o as R, a as O } from "./utils-nUjUW0ze.js";
+try {
+  let n = typeof window < "u" ? window : typeof global < "u" ? global : typeof globalThis < "u" ? globalThis : typeof self < "u" ? self : {}, o = new n.Error().stack;
+  o && (n._sentryDebugIds = n._sentryDebugIds || {}, n._sentryDebugIds[o] = "c1498ce3-2175-4bad-9ff6-aea1cfab578d", n._sentryDebugIdIdentifier = "sentry-dbid-c1498ce3-2175-4bad-9ff6-aea1cfab578d");
+} catch {
+}
+const Y = Q(), Z = (n) => {
+  const [o, g] = H({}), t = V((l) => {
+    g((r) => ({
+      ...r,
+      [l]: void 0
+    }));
+  }, []), a = V(
+    (l, r, v) => {
+      const s = n?.[l];
+      if (!s || !s.modes.includes(v)) {
+        t(l);
+        return;
+      }
+      const p = r.data[l];
+      return s.asyncValidate(r.data[l], { state: r }).then((b) => {
+        g((c) => ({
+          ...c,
+          [l]: new j([
+            {
+              isValid: b,
+              errorMessage: typeof s.errorMessage == "function" ? s.errorMessage(p, { state: r }) : s.errorMessage,
+              hasError: !b
+            }
+          ])
+        }));
+      }).catch(Y.error);
+    },
+    [n, t]
+  );
+  return {
+    asyncValidationResults: o,
+    triggerAsyncValidation: a,
+    clearAsyncValidationResults: t
+  };
+}, $ = (n) => {
+  const o = V(
+    (t) => {
+      const a = {
+        validate: () => !0,
+        modes: ["blur", "input"]
+      }, l = n?.[t] ?? [a];
+      return Array.isArray(l) ? l : [l];
+    },
+    [n]
+  );
+  return {
+    triggerStaticValidation: V(
+      ({ key: t, value: a, mode: l = "blur" }, r) => {
+        const v = o(t), s = !!r?.state.optionalFields?.includes(t), p = !!r?.state.obscuredFields?.includes(t), b = v.map((c) => {
+          const u = c.modes.includes(l) && !p, m = s && X(a) ? !0 : c.validate(a, r);
+          return {
+            isValid: m,
+            errorMessage: typeof c.errorMessage == "function" ? c.errorMessage(a, r) : c.errorMessage,
+            hasError: u && !m
+          };
+        });
+        return new j(b);
+      },
+      [o]
+    )
+  };
+}, q = ({
+  key: n,
+  value: o = null,
+  mode: g,
+  defaultData: t,
+  fieldContext: a,
+  formatters: l,
+  staticValidate: r,
+  asyncValidate: v
+}) => {
+  const s = l?.[n]?.formatter ? l[n]?.formatter : l?.[n], p = s && typeof s == "function" ? s(o, a) : o, b = !(t?.[n] === o && t?.[n]);
+  b && o && v(n, a.state, g);
+  const c = b ? r({ key: n, value: p, mode: g }, a) : new j([
+    {
+      isValid: !0,
+      hasError: !1
+    }
+  ]);
+  return [p, c];
+};
+function J({
+  schema: n,
+  defaultData: o,
+  fieldProblems: g,
+  obscuredFields: t,
+  optionalFields: a,
+  trustedFields: l,
+  formatters: r,
+  staticValidate: v,
+  asyncValidate: s
+}) {
+  const p = (u) => {
+    const [m, P] = q({
+      key: u,
+      value: o?.[u],
+      mode: "blur",
+      formatters: r,
+      defaultData: o,
+      fieldContext: {
+        state: {
+          data: o,
+          obscuredFields: t,
+          optionalFields: a,
+          trustedFields: l
+        }
+      },
+      staticValidate: v,
+      asyncValidate: s
+    });
+    return typeof o?.[u] > "u" ? {
+      valid: P.isValid && !g?.[u] || !1,
+      errors: null,
+      data: null,
+      fieldProblems: g?.[u] ?? !1
+    } : {
+      valid: P.isValid && !g?.[u] || !1,
+      errors: P.getError() ?? null,
+      data: m,
+      fieldProblems: g?.[u] ?? !1
+    };
+  };
+  return (a ? [...n, ...a] : n).reduce(
+    (u, m) => {
+      const {
+        valid: P,
+        errors: S,
+        data: M,
+        fieldProblems: e
+      } = p(m);
+      return {
+        ...u,
+        data: { ...u.data, [m]: M },
+        valid: { ...u.valid, [m]: P },
+        errors: { ...u.errors, [m]: S },
+        fieldProblems: { ...u.fieldProblems, [m]: e }
+      };
+    },
+    {
+      schema: n,
+      data: {},
+      valid: {},
+      errors: {},
+      fieldProblems: {},
+      obscuredFields: t,
+      optionalFields: a,
+      trustedFields: l
+    }
+  );
+}
+function K({
+  staticValidate: n,
+  asyncValidate: o,
+  obscuredFields: g,
+  optionalFields: t,
+  trustedFields: a,
+  formatters: l
+}) {
+  return (r, {
+    type: v,
+    key: s,
+    mode: p,
+    value: b,
+    schema: c,
+    selectedSchema: u,
+    formValue: m,
+    fieldProblems: P,
+    defaultData: S
+  }) => {
+    const M = u || r.schema;
+    switch (v) {
+      case "setData":
+        return s ? { ...r, data: { ...r.data, [s]: b } } : r;
+      case "setValid":
+        return s ? { ...r, valid: { ...r.valid, [s]: b } } : r;
+      case "setErrors":
+        return s ? { ...r, errors: { ...r.errors, [s]: b } } : r;
+      case "setFieldProblems":
+        return r?.schema?.reduce(
+          (e, d) => ({
+            ...e,
+            fieldProblems: {
+              ...r.fieldProblems,
+              [d]: P?.[d] ?? !1
+            },
+            valid: { ...r.valid, [d]: r.valid?.[d] && !P?.[d] }
+          }),
+          r
+        );
+      case "setSchema": {
+        if (!c) return r;
+        const e = J({
+          schema: c,
+          // requiredFields
+          defaultData: S,
+          fieldProblems: P,
+          obscuredFields: g,
+          optionalFields: t,
+          trustedFields: a,
+          staticValidate: n,
+          asyncValidate: o
+        }), d = r.optionalFields?.length ? [
+          ...r.schema.filter((h) => !c.includes(h)),
+          ...r.optionalFields.filter((h) => !t?.includes(h))
+        ] : r.schema.filter((h) => !c.includes(h)), f = t?.length ? [
+          ...c.filter((h) => !r.schema?.includes(h)),
+          ...t.filter((h) => !r.optionalFields?.includes(h))
+        ] : c.filter((h) => !r.schema?.includes(h)), y = {
+          data: R(r.data, f),
+          errors: R(r.errors, f),
+          valid: R(r.valid, f),
+          fieldProblems: R(r.fieldProblems, f)
+        }, F = O(
+          R(r.data, d),
+          f,
+          null,
+          e.data,
+          r.local?.data
+        ), w = O(
+          R(r.valid, d),
+          f,
+          !1,
+          e.valid,
+          r.local?.valid
+        ), A = O(
+          R(r.errors, d),
+          f,
+          null,
+          e.errors,
+          r.local?.errors
+        ), T = O(
+          R(r.fieldProblems, d),
+          f,
+          !1,
+          e.fieldProblems,
+          r.local?.fieldProblems
+        );
+        return {
+          ...r,
+          schema: c,
+          data: F,
+          valid: w,
+          errors: A,
+          fieldProblems: T,
+          obscuredFields: g,
+          optionalFields: t,
+          trustedFields: a,
+          local: y
+        };
+      }
+      case "updateField": {
+        if (!s || !p) return r;
+        const [e, d] = q({
+          key: s,
+          value: b,
+          mode: p,
+          defaultData: S,
+          formatters: l,
+          fieldContext: { state: r },
+          staticValidate: n,
+          asyncValidate: o
+        }), y = r.data[s] !== e;
+        return {
+          ...r,
+          data: { ...r.data, [s]: e },
+          errors: {
+            ...r.errors,
+            [s]: d.getError() ?? null
+          },
+          valid: {
+            ...r.valid,
+            [s]: d.isValid && !r.fieldProblems?.[s] || !1
+          },
+          fieldProblems: {
+            ...r.fieldProblems,
+            [s]: y ? !1 : r.fieldProblems?.[s] ?? !1
+          }
+        };
+      }
+      case "mergeForm": {
+        const e = {
+          ...r,
+          data: { ...r.data, ...m?.data },
+          errors: { ...r.errors, ...m?.errors },
+          valid: { ...r.valid, ...m?.valid },
+          fieldProblems: { ...r.fieldProblems, ...m?.fieldProblems }
+        };
+        return e.valid && (e.isValid = Object.values(e.valid).every((d) => d)), e;
+      }
+      case "validateForm": {
+        const e = M?.reduce(
+          (d, f) => {
+            const [y, F] = q({
+              key: f,
+              value: r.data[f],
+              mode: "blur",
+              defaultData: S,
+              formatters: l,
+              fieldContext: { state: r },
+              staticValidate: n,
+              asyncValidate: o
+            }), A = r.data[f] !== y;
+            return {
+              valid: {
+                ...d.valid,
+                [f]: F.isValid && !r.fieldProblems?.[f] || !1
+              },
+              errors: {
+                ...d.errors,
+                [f]: F.getError() ?? null
+              },
+              fieldProblems: {
+                ...d.fieldProblems,
+                [f]: A ? !1 : r.fieldProblems?.[f] ?? !1
+              }
+            };
+          },
+          { valid: r.valid, errors: r.errors, fieldProblems: r.fieldProblems }
+        );
+        return {
+          ...r,
+          valid: e?.valid,
+          errors: e?.errors,
+          fieldProblems: e?.fieldProblems
+        };
+      }
+      default:
+        throw new Error("Undefined useForm action");
+    }
+  };
+}
+const D = (n, o, g, t, a) => {
+  const l = a ? [...g, ...a] : g;
+  return l.length ? l.reduce(
+    (v, s) => (o[s]?.getError() && t(s, !1), {
+      ...v,
+      [s]: n[s] ?? o[s]?.getError() ?? null
+    }),
+    {}
+  ) : n;
+};
+function or({
+  schema: n,
+  defaultData: o,
+  rules: g,
+  asyncRules: t,
+  fieldProblems: a,
+  obscuredFields: l,
+  optionalFields: r,
+  trustedFields: v,
+  formatters: s,
+  shouldValidate: p = !1
+}) {
+  const { triggerStaticValidation: b } = $(g), { triggerAsyncValidation: c, asyncValidationResults: u } = Z(t), m = I(
+    () => typeof n == "function" ? n : () => n,
+    [n]
+  ), P = I(
+    () => o ? m(o) : [],
+    [o, m]
+  ), S = V(
+    () => K({
+      staticValidate: b,
+      asyncValidate: c,
+      obscuredFields: l,
+      optionalFields: r,
+      trustedFields: v,
+      formatters: s
+    }),
+    [
+      b,
+      c,
+      l,
+      r,
+      v,
+      s
+    ]
+  ), M = I(
+    () => ({
+      schema: P,
+      defaultData: o,
+      fieldProblems: a,
+      obscuredFields: l,
+      optionalFields: r,
+      trustedFields: v,
+      formatters: s,
+      staticValidate: b,
+      asyncValidate: c
+    }),
+    [
+      P,
+      o,
+      a,
+      l,
+      r,
+      v,
+      s,
+      b,
+      c
+    ]
+  ), [e, d] = G(S(), M, J), f = I(
+    () => e.schema?.every((i) => e.valid[i]),
+    [e.schema, e.valid]
+  ), y = V(
+    (i, E) => E?.target ? E.target.type === "checkbox" ? !e.data[i] : E.target.value : E,
+    [e.data]
+  ), F = V((i, E) => {
+    d({ type: "setErrors", key: i, value: E });
+  }, []), w = V((i, E) => {
+    d({ type: "setValid", key: i, value: E });
+  }, []), A = V((i, E) => {
+    d({ type: "setData", key: i, value: E });
+  }, []), T = V(
+    (i) => {
+      d({ type: "setSchema", schema: i, defaultData: o });
+    },
+    [o]
+  ), h = V(
+    (i) => {
+      d({ type: "setFieldProblems", fieldProblems: i });
+    },
+    []
+  ), L = V((i) => {
+    d({ type: "mergeForm", formValue: i });
+  }, []), _ = V(
+    (i, E = "blur") => (z) => {
+      const B = y(i, z);
+      d({
+        type: "updateField",
+        key: i,
+        value: B,
+        mode: E,
+        defaultData: o
+      });
+    },
+    [o, y]
+  ), x = V(
+    (i) => {
+      d({
+        type: "validateForm",
+        selectedSchema: i,
+        defaultData: o
+      });
+    },
+    [o]
+  ), N = V(() => {
+    P.forEach((i) => {
+      if (!o || typeof o[i] < "u") {
+        _(i)(o?.[i]);
+        return;
+      }
+      w(i, !1), F(i, null), A(i, o[i]);
+    });
+  }, [o, P, _, A, F, w]);
+  C(() => {
+    const i = m(e.data);
+    W(e.schema, i) || T(i);
+  }, [e.schema, e.data, T, m]), C(() => {
+    p && x();
+  }, [p, e.schema]), C(() => {
+    a && h(a);
+  }, [JSON.stringify(a), h]);
+  const U = I(
+    () => D(
+      e.errors,
+      u,
+      e.schema,
+      w,
+      e.optionalFields
+    ),
+    [u, e.errors, e.optionalFields, e.schema]
+  );
+  return {
+    mergeForm: L,
+    setData: A,
+    setValid: w,
+    setErrors: F,
+    setFieldProblems: h,
+    handleChangeFor: _,
+    triggerValidation: x,
+    resetToDefaultData: N,
+    isValid: f,
+    schema: e.schema,
+    valid: e.valid,
+    errors: U,
+    data: e.data,
+    fieldProblems: e.fieldProblems
+  };
+}
+export {
+  or as u
+};

package/dist/es/external/.pnpm/@adyen_kyc-components@4.0.0-compact.9_react@19.2.0_typescript@5.8.3/node_modules/@adyen/kyc-components/dist/useFormContext-CX6rQNws.js

@@ -0,0 +1,158 @@
+import { jsx as o } from "../../../../../preact@10.29.0/node_modules/preact/jsx-runtime/dist/jsxRuntime.module.js";
+import { useRef as G, useState as N, useMemo as H, useContext as J } from "../../../../../preact@10.29.0/node_modules/preact/hooks/dist/hooks.module.js";
+import K from "classnames";
+import { z as Q, u as U, W as i } from "./StoreProvider-CBB99upB.js";
+import { L as X } from "./LoaderWrapper-BL7Hc_DC.js";
+import { M as Y } from "./MaybeModal-7NGTfxO6.js";
+import { P as Z } from "./ProgressBar-B7gTQncy.js";
+import { F as $ } from "./dropinUtils-D44Paj5u.js";
+import { C as oo } from "./Confirm-NubmSSR7.js";
+import { S as eo } from "./Summary-C5uRwUKn.js";
+import { createContext as no } from "../../../../../preact@10.29.0/node_modules/preact/dist/preact.module.js";
+try {
+  let n = typeof window < "u" ? window : typeof global < "u" ? global : typeof globalThis < "u" ? globalThis : typeof self < "u" ? self : {}, s = new n.Error().stack;
+  s && (n._sentryDebugIds = n._sentryDebugIds || {}, n._sentryDebugIds[s] = "8b1b752a-12c0-4345-9fff-f44cb1a28f1d", n._sentryDebugIdIdentifier = "sentry-dbid-8b1b752a-12c0-4345-9fff-f44cb1a28f1d");
+} catch {
+}
+const S = no(null);
+function Co({
+  children: n,
+  form: s
+}) {
+  const a = H(
+    () => ({
+      form: s
+    }),
+    [s]
+  );
+  return /* @__PURE__ */ o(S.Provider, { value: a, children: n });
+}
+const so = "adyen-kyc-form-flow", to = "adyen-kyc-form-flow-content", ro = "adyen-kyc-form-flow-footer", ao = "adyen-kyc-form-flow-footer-border", io = "adyen-kyc-form-flow-actions", lo = "adyen-kyc-form-flow-primary-actions", r = {
+  formFlow: so,
+  formFlowContent: to,
+  formFlowFooter: ro,
+  formFlowFooterBorder: ao,
+  formFlowActions: io,
+  formFlowPrimaryActions: lo
+}, xo = ({
+  asModal: n = !1,
+  children: s,
+  currentStep: a = 0,
+  disableBackButton: y,
+  disableNextButton: B,
+  nextButtonLoading: M = !1,
+  // used to separate button loading state from loading wrapper
+  forms: b,
+  activeForm: E,
+  gotoFormByFormIndex: h,
+  handleBackClick: g,
+  handleCancelClick: p,
+  handleNextClick: w,
+  loadingStatus: F,
+  summary: v,
+  summaryComponent: C,
+  totalSteps: l = 1
+}) => {
+  const c = G(null), x = Q(), { t } = U("common"), [P, d] = N(!1), [k, D] = N(!1), f = k || P || F === "loading", R = !!g, m = !!p, T = a === 0, A = a === l - 1, I = l < 2, _ = Math.floor(a / (l - 1) * 100), u = () => {
+    c.current && c.current.scroll({
+      top: 0,
+      behavior: "smooth"
+    });
+  }, z = () => {
+    D(!0), Promise.resolve(w()).then(() => {
+      D(!1), u();
+    });
+  }, W = () => {
+    u(), w();
+  }, V = () => {
+    u(), g?.();
+  }, L = () => {
+    m && d(!0);
+  }, j = () => {
+    x.addPageEvent("Closed modal", {
+      actionType: "close",
+      label: "cancel"
+    }), d(!1);
+  }, O = () => {
+    x.addPageEvent("Clicked button", {
+      actionType: "navigate",
+      label: "leave"
+    }), d(!1), p?.();
+  }, q = K(r.formFlowFooter, {
+    [r.formFlowFooterBorder]: I
+  });
+  return /* @__PURE__ */ o(
+    Y,
+    {
+      inline: !n,
+      onClose: L,
+      size: "large",
+      showCloseButton: m,
+      children: [
+        /* @__PURE__ */ o(
+          "div",
+          {
+            ref: c,
+            className: r.formFlow,
+            "data-form-valid": E.isValid,
+            "data-testid": "form-flow",
+            children: [
+              /* @__PURE__ */ o("div", { className: r.formFlowContent, children: /* @__PURE__ */ o(X, { status: F, formOpacityWhenLoading: 0, loaderSize: "large", children: /* @__PURE__ */ o($, { forms: b, setFormIndex: h, children: A ? C || (v !== void 0 ? /* @__PURE__ */ o(eo, { ...v, forms: b, gotoForm: h }) : s) : s }) }) }),
+              /* @__PURE__ */ o("div", { className: q, children: [
+                !I && /* @__PURE__ */ o(Z, { ariaLabel: t((e) => e.progress), progress: _ }),
+                /* @__PURE__ */ o("div", { className: r.formFlowActions, children: [
+                  T && m && /* @__PURE__ */ o(
+                    i,
+                    {
+                      disabled: f || y,
+                      onClick: L,
+                      variant: "secondary",
+                      children: t((e) => e.cancel)
+                    }
+                  ),
+                  !T && R && /* @__PURE__ */ o(
+                    i,
+                    {
+                      disabled: f || y,
+                      icon: "chevron-left",
+                      onClick: V,
+                      variant: "secondary",
+                      children: t((e) => e.back)
+                    }
+                  ),
+                  /* @__PURE__ */ o("div", { className: r.formFlowPrimaryActions, children: A ? /* @__PURE__ */ o(i, { onClick: z, loading: k, children: t((e) => e.submit) }) : /* @__PURE__ */ o(
+                    i,
+                    {
+                      onClick: W,
+                      disabled: f || B,
+                      loading: M,
+                      children: t((e) => e.continue)
+                    }
+                  ) })
+                ] })
+              ] })
+            ]
+          }
+        ),
+        P && /* @__PURE__ */ o(
+          oo,
+          {
+            confirmText: t((e) => e.leave),
+            description: t((e) => e.unsavedChangesDescription),
+            onCancel: j,
+            onConfirm: O,
+            title: t((e) => e.unsavedChanges)
+          }
+        )
+      ]
+    }
+  );
+};
+function Po() {
+  return J(S);
+}
+export {
+  Co as F,
+  xo as a,
+  Po as u
+};

package/dist/es/external/.pnpm/@adyen_kyc-components@4.0.0-compact.9_react@19.2.0_typescript@5.8.3/node_modules/@adyen/kyc-components/dist/useId-BZ0PA7jP.js

@@ -0,0 +1,20 @@
+import { useState as t } from "../../../../../preact@10.29.0/node_modules/preact/hooks/dist/hooks.module.js";
+try {
+  let e = typeof window < "u" ? window : typeof global < "u" ? global : typeof globalThis < "u" ? globalThis : typeof self < "u" ? self : {}, x = new e.Error().stack;
+  x && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[x] = "1b45db25-e530-4076-9ec1-2e9652ae80b0", e._sentryDebugIdIdentifier = "sentry-dbid-1b45db25-e530-4076-9ec1-2e9652ae80b0");
+} catch {
+}
+function n() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (e) => {
+    let x = Math.random() * 16 | 0;
+    return (e == "x" ? x : x & 3 | 8).toString(16);
+  });
+}
+const s = (e) => {
+  const [x] = t(n());
+  return `${e}_${x}`;
+};
+export {
+  s as a,
+  n as u
+};