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

package/dist/es/components/utils/getLabel.js

@@ -0,0 +1,20 @@
+const e = {
+  id: "paymentId",
+  transactionType: "transactionType",
+  createdAt: "date",
+  balanceAccountId: "balanceAccount",
+  accountHolderId: "account",
+  amount: "txAmount",
+  description: "description",
+  status: "status",
+  category: "category",
+  paymentMethod: "paymentMethod",
+  currency: "currency",
+  fundsCapturedAmount: "fundsCaptured",
+  payoutAmount: "netPayout",
+  adjustmentAmount: "adjustments",
+  dateAndPaymentMethod: "date"
+}, n = (t) => e[t] || t;
+export {
+  n as getLabel
+};

package/dist/es/core/Auth/context.js

@@ -0,0 +1,24 @@
+import { jsx as c } from "../../external/preact/jsx-runtime/dist/jsxRuntime.module.js";
+import { createContext as p, toChildArray as f } from "../../external/preact/dist/preact.module.js";
+import { useContext as m, useState as e, useEffect as d } from "../../external/preact/hooks/dist/hooks.module.js";
+import { asyncNoop as h, noop as C } from "../../utils/common.js";
+import { isWatchlistUnsubscribeToken as x } from "../../primitives/reactive/watchlist/main.js";
+import { EMPTY_OBJECT as b } from "../../utils/value/constants.js";
+const r = p({
+  endpoints: b,
+  hasError: !1,
+  http: h,
+  isExpired: void 0,
+  refresh: C,
+  refreshing: !1
+}), y = ({ children: o, session: t }) => {
+  const [, s] = e(0), [n, a] = e(0);
+  return d(() => t.subscribe((u) => {
+    (x(u) ? a : s)((i) => i + 1);
+  }), [n, t]), /* @__PURE__ */ c(r.Provider, { value: t.context, children: f(o) });
+}, J = () => m(r);
+export {
+  y as AuthProvider,
+  J as default,
+  J as useAuthContext
+};

package/dist/es/core/Auth/session/AuthSession.js

@@ -0,0 +1,99 @@
+var c = Object.defineProperty;
+var p = (i, e, t) => e in i ? c(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t;
+var s = (i, e, t) => (p(i, typeof e != "symbol" ? e + "" : e, t), t);
+import l from "./AuthSetupContext.js";
+import m from "./AuthSessionSpecification.js";
+import { EVT_AUTH_STATE_CHANGE as n, ERR_AUTH_REFRESH_FAILED as h, ERR_AUTH_REFRESH_ABORTED as a } from "./constants.js";
+import { createErrorContainer as S } from "../../../primitives/auxiliary/errorContainer/main.js";
+import { createEventEmitter as C } from "../../../primitives/reactive/eventEmitter/main.js";
+import { createAbortable as d } from "../../../primitives/async/abortable/main.js";
+import { SessionContext as b } from "../../../primitives/context/session/SessionContext.js";
+import { createWatchlist as E } from "../../../primitives/reactive/watchlist/main.js";
+import { constant as _, noop as u } from "../../../utils/common.js";
+import { EVT_SESSION_REFRESHING_STATE_CHANGE as A, EVT_SESSION_EXPIRED_STATE_CHANGE as x } from "../../../primitives/context/session/constants.js";
+import { isFunction as f } from "../../../utils/value/is.js";
+import { boolOrFalse as R } from "../../../utils/value/bool.js";
+class D {
+  constructor() {
+    s(this, "_canSkipSessionRefresh", !1);
+    s(this, "_lastSessionContextRefreshTimestamp");
+    s(this, "_overrideRefreshInProgress", !1);
+    s(this, "_refreshInProgress", !1);
+    s(this, "_errorContainer", S());
+    s(this, "_eventEmitter", C());
+    s(this, "_refreshAbortable", d(a));
+    s(this, "_specification", new m());
+    s(this, "_sessionContext", new b(this._specification));
+    s(this, "_setupContext", new l(this._sessionContext));
+    s(this, "_watchlist", E({
+      endpoints: () => this._setupContext.endpoints,
+      hasError: () => this._errorContainer.hasError,
+      http: _(this._sessionContext.http.bind(this._sessionContext)),
+      isExpired: () => this._sessionContext.isExpired,
+      refresh: _(this._overrideRefresh.bind(this)),
+      refreshing: () => this._sessionContext.refreshing
+    }));
+    this.destroy = () => {
+      this._watchlist.on.resume = void 0, this._watchlist.cancelSubscriptions();
+    };
+    const e = this._onAuthStateChanged.bind(this), t = this._onSessionExpiredStateChange.bind(this);
+    this._refreshAbortablePromise = this._refreshAbortablePromise.bind(this), this.subscribe = this._watchlist.subscribe, this._watchlist.on.resume = () => {
+      let r = [
+        this._eventEmitter.on(n, this._watchlist.requestNotification),
+        this._sessionContext.on(A, e),
+        this._sessionContext.on(x, t)
+      ];
+      this._watchlist.on.idle = () => {
+        this._watchlist.on.idle = void 0, r.forEach((o) => o()), r.length = 0, r = void 0;
+      }, this._refresh();
+    };
+  }
+  get context() {
+    return this._watchlist.snapshot;
+  }
+  set loadingContext(e) {
+    this._setupContext.loadingContext = e;
+  }
+  set onSessionCreate(e) {
+    this._specification.onSessionCreate !== e && (this._specification.onSessionCreate = e, this._refreshInProgress && f(this._specification.onSessionCreate) && (this._canSkipSessionRefresh = !1, this._overrideRefresh()));
+  }
+  _onAuthStateChanged() {
+    this._eventEmitter.emit(n);
+  }
+  _onSessionExpiredStateChange() {
+    const { timestamp: e } = this._sessionContext;
+    (this._canSkipSessionRefresh = this._lastSessionContextRefreshTimestamp !== e) && (this._lastSessionContextRefreshTimestamp = e, this._errorContainer.reset(), this._overrideRefresh()), this._onAuthStateChanged();
+  }
+  _overrideRefresh(e = this._canSkipSessionRefresh) {
+    this._overrideRefreshInProgress = !0, this._refresh(e);
+  }
+  _refresh(e = !1) {
+    if (this._refreshInProgress && !this._overrideRefreshInProgress)
+      return;
+    this._overrideRefreshInProgress && (this._overrideRefreshInProgress = !1, this._refreshAbortable.abort(), this._refreshAbortable.refresh()), this._refreshInProgress = !0, (R(e) && this._canSkipSessionRefresh ? this._refreshSetupContext() : this._refreshAbortablePromise(this._sessionContext.refresh)).catch(u);
+  }
+  async _refreshSetupContext() {
+    let e = !1;
+    await this._setupContext.refresh(this._refreshAbortablePromise).then(
+      () => this._errorContainer.reset(),
+      (t) => e = t !== h
+    ).then(() => {
+      this._refreshInProgress = e, this._onAuthStateChanged();
+    });
+  }
+  async _refreshAbortablePromise(e) {
+    const t = this._refreshAbortable.signal;
+    return (async () => {
+      const r = f(e) ? e(t) : e, o = await Promise.race([r, this._refreshAbortable.promise]);
+      if (t.aborted)
+        throw void 0;
+      return o;
+    })().catch((r) => {
+      throw t.aborted ? a : (this._errorContainer.set(r), h);
+    });
+  }
+}
+export {
+  D as AuthSession,
+  D as default
+};

package/dist/es/core/Auth/session/AuthSessionSpecification.js

@@ -0,0 +1,63 @@
+var d = Object.defineProperty;
+var l = (i, t, r) => t in i ? d(i, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : i[t] = r;
+var s = (i, t, r) => (l(i, typeof t != "symbol" ? t + "" : t, r), r);
+import { http as h } from "../../Http/http.js";
+import { ErrorTypes as m } from "../../Http/utils.js";
+import { AUTO_REFRESH as u, MAX_AGE_MS as a } from "./constants.js";
+import { isPlainObject as A, isString as c, isUndefined as E } from "../../../utils/value/is.js";
+import { isAbortSignal as S, createAbortSink as R } from "../../../primitives/auxiliary/abortSink/main.js";
+import { ERR_SESSION_EXPIRED as g } from "../../../primitives/context/session/constants.js";
+import { enumerable as k, getter as O } from "../../../utils/struct/property.js";
+import { noop as w } from "../../../utils/common.js";
+class _ {
+  constructor(t) {
+    s(this, "assert", (t) => {
+      if (A(t)) {
+        const r = c(t.id) ? t.id.trim() : void 0, e = c(t.token) ? t.token.trim() : void 0;
+        if (r && e)
+          return;
+      }
+      throw void 0;
+    });
+    s(this, "deadline", (t) => {
+      let r, e;
+      try {
+        ({ iat: r, exp: e } = JSON.parse(atob(t.token.split(".")[1])));
+      } catch {
+        r = Date.now();
+      }
+      if (!E(a)) {
+        const n = new Date(r);
+        return Math.min(e ?? 1 / 0, n.setMilliseconds(n.getMilliseconds() + a));
+      }
+      return e;
+    });
+    s(this, "http", async (t, r, e, n) => {
+      let { abort: f = w, signal: p } = S(e.signal) ? R(r, e.signal) : { signal: r };
+      try {
+        const o = {
+          ...e,
+          signal: p,
+          headers: {
+            ...e.headers,
+            ...t && { Authorization: `Bearer ${t.token}` }
+          }
+        };
+        return await h(o, n);
+      } catch (o) {
+        throw (o == null ? void 0 : o.type) === m.EXPIRED_TOKEN ? g : o;
+      } finally {
+        f();
+      }
+    });
+    this.onSessionCreate = t, Object.defineProperties(this, {
+      autoRefresh: k(u),
+      onRefresh: O(() => this.onSessionCreate, !0)
+    });
+  }
+}
+const X = _;
+export {
+  _ as AuthSessionSpecification,
+  X as default
+};

package/dist/es/core/Auth/session/AuthSetupContext.js

@@ -0,0 +1,64 @@
+var d = Object.defineProperty;
+var m = (r, t, e) => t in r ? d(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
+var u = (r, t, e) => (m(r, typeof t != "symbol" ? t + "" : t, e), e);
+import { SETUP_ENDPOINT_PATH as P } from "./constants.js";
+import { parseSearchParams as E } from "../../Http/utils.js";
+import { EMPTY_OBJECT as _ } from "../../../utils/value/constants.js";
+import { noop as f } from "../../../utils/common.js";
+import { struct as l, withFreezeProxyHandlers as x, asPlainObject as y } from "../../../utils/struct/main.js";
+import { isPlainObject as g, isUndefined as O } from "../../../utils/value/is.js";
+class S {
+  constructor(t) {
+    u(this, "_endpoints", _);
+    u(this, "_revokeEndpointsProxy", f);
+    this._session = t, this._fetchSetupEndpoint = this._fetchSetupEndpoint.bind(this), this.refresh = this.refresh.bind(this);
+  }
+  get endpoints() {
+    return this._endpoints;
+  }
+  async refresh(t) {
+    this._resetEndpoints();
+    const { endpoints: e } = await t(this._fetchSetupEndpoint);
+    ({ proxy: this._endpoints, revoke: this._revokeEndpointsProxy } = this._getEndpointsProxy(e));
+  }
+  _fetchSetupEndpoint(t) {
+    return this._session.http({
+      method: "POST",
+      path: P,
+      errorLevel: "fatal",
+      loadingContext: this.loadingContext,
+      signal: t
+    });
+  }
+  _getEndpointsProxy(t) {
+    const e = new Set(Object.keys(t)), o = l();
+    return Proxy.revocable(
+      _,
+      x({
+        get: (a, s, p) => e.has(s) ? (o[s] ?? (o[s] = (() => {
+          const { method: n = "GET", url: i } = t[s];
+          if (!O(i || void 0))
+            return (...c) => {
+              const h = this._getHttpOptions(n, i, ...c);
+              return this._session.http(h);
+            };
+        })()), o[s]) : Reflect.get(a, s, p)
+      })
+    );
+  }
+  _getHttpOptions(t, e, ...o) {
+    const { loadingContext: a } = this, [s, p] = o, { path: n, query: i } = y(p), c = i && E(i);
+    if (g(n))
+      for (const h of Object.keys(n))
+        e = e.replace(`{${h}}`, n[h]);
+    return { loadingContext: a, ...s, method: t, params: c, path: e };
+  }
+  _resetEndpoints() {
+    this._revokeEndpointsProxy(), this._revokeEndpointsProxy = f, this._endpoints = _;
+  }
+}
+const q = S;
+export {
+  S as AuthSetupContext,
+  q as default
+};

package/dist/es/core/Auth/session/constants.js

@@ -0,0 +1,14 @@
+import { boolOrFalse as _ } from "../../../utils/value/bool.js";
+const A = Symbol("Error<AUTH_REFRESH_ABORTED>"), R = Symbol("Error<AUTH_REFRESH_FAILED>"), o = "_authStateChange", e = "/setup", T = _(void 0), n = (() => {
+  let E = 0;
+  if (Number.isFinite(E) && (E = Math.max(0, ~~E)))
+    return E;
+})();
+export {
+  T as AUTO_REFRESH,
+  A as ERR_AUTH_REFRESH_ABORTED,
+  R as ERR_AUTH_REFRESH_FAILED,
+  o as EVT_AUTH_STATE_CHANGE,
+  n as MAX_AGE_MS,
+  e as SETUP_ENDPOINT_PATH
+};

package/dist/es/core/Context/CoreContext.js

@@ -1,10 +1,12 @@
 import { createContext as o } from "../../external/preact/dist/preact.module.js";
 import t from "../Localization/Localization.js";
-const r = o({
+import { noop as n } from "../../utils/common.js";
+const m = o({
   i18n: new t().i18n,
   loadingContext: "",
-  commonProps: {}
+  commonProps: {},
+  updateCore: n
 });
 export {
-  r as CoreContext
+  m as CoreContext
 };

package/dist/es/core/Context/CoreProvider.js

@@ -1,22 +1,23 @@
-import { jsx as i } from "../../external/preact/jsx-runtime/dist/jsxRuntime.module.js";
-import { toChildArray as f } from "../../external/preact/dist/preact.module.js";
-import { useMemo as t, useEffect as d } from "../../external/preact/hooks/dist/hooks.module.js";
-import { CoreContext as l } from "./CoreContext.js";
+import { jsx as f } from "../../external/preact/jsx-runtime/dist/jsxRuntime.module.js";
+import { toChildArray as d } from "../../external/preact/dist/preact.module.js";
+import { useMemo as t, useEffect as l } from "../../external/preact/hooks/dist/hooks.module.js";
+import { CoreContext as u } from "./CoreContext.js";
 import p from "../../hooks/useBooleanState/useBooleanState.js";
-import u from "../Localization/Localization.js";
-const C = ({
-  i18n: o = new u().i18n,
+import C from "../Localization/Localization.js";
+const y = ({
+  i18n: o = new C().i18n,
   children: a,
   commonProps: r,
-  loadingContext: e
+  loadingContext: e,
+  updateCore: s
 }) => {
-  const [s, m] = p(!1), n = t(() => r || {}, [r]), c = t(() => e ?? "", [e]);
-  return d(() => {
+  const [m, n] = p(!1), c = t(() => r || {}, [r]), i = t(() => e ?? "", [e]);
+  return l(() => {
     (async () => {
-      await (o == null ? void 0 : o.ready), m(!0);
+      await (o == null ? void 0 : o.ready), n(!0);
     })().catch();
-  }, []), s ? /* @__PURE__ */ i(l.Provider, { value: { i18n: o, commonProps: n, loadingContext: c }, children: f(a) }) : null;
-}, g = C;
+  }, []), m ? /* @__PURE__ */ f(u.Provider, { value: { i18n: o, commonProps: c, loadingContext: i, updateCore: s }, children: d(a) }) : null;
+}, j = y;
 export {
-  g as default
+  j as default
 };

package/dist/es/core/Http/http.js

@@ -0,0 +1,42 @@
+import { API_VERSION as m } from "./constants.js";
+import { normalizeLoadingContext as u, normalizeUrl as f } from "../utils.js";
+import { getRequestObject as g, getErrorType as y, isAdyenErrorResponse as w, handleFetchError as C } from "./utils.js";
+async function $(t, c) {
+  const { errorLevel: l, loadingContext: d = "", path: i } = t, h = g(t, c), s = new URL(`${u(d)}${m}${f(i)}`);
+  return t.params && t.params.forEach((o, r) => {
+    const e = decodeURIComponent(o);
+    e && s.searchParams.append(r, e);
+  }), (async () => {
+    let o = !1;
+    const r = { level: l };
+    try {
+      const e = await fetch(s, h);
+      if (e.ok)
+        try {
+          return await e.json();
+        } catch (n) {
+          throw o = !0, n;
+        }
+      r.type = y(e.status);
+      const a = await e.json();
+      if (r.message = t.errorMessage || `Service at ${s} not available`, r.errorCode = String(a.status), r.requestId = a == null ? void 0 : a.requestId, w(a)) {
+        if (t.errorHandler)
+          try {
+            t.errorHandler(a);
+            return;
+          } catch (n) {
+            throw o = !0, n;
+          }
+        r.message = a.detail, r.errorCode = a.errorCode;
+      }
+    } catch (e) {
+      if (o)
+        throw e;
+      r.message = t.errorMessage || `Call to ${s} failed. Error: ${e}`;
+    }
+    C(r);
+  })();
+}
+export {
+  $ as http
+};

package/dist/es/core/{Services/requests → Http}/utils.js

@@ -1,16 +1,17 @@
-import c from "../../Errors/AdyenPlatformExperienceError.js";
-var R = /* @__PURE__ */ ((e) => (e.NETWORK_ERROR = "NETWORK_ERROR", e.CANCEL = "CANCEL", e.IMPLEMENTATION_ERROR = "IMPLEMENTATION_ERROR", e.ERROR = "ERROR", e.EXPIRED_TOKEN = "EXPIRED_TOKEN", e))(R || {});
-const s = (e) => {
+import c from "../Errors/AdyenPlatformExperienceError.js";
+import { isNullish as i } from "../../utils/value/is.js";
+var s = /* @__PURE__ */ ((e) => (e.NETWORK_ERROR = "NETWORK_ERROR", e.CANCEL = "CANCEL", e.IMPLEMENTATION_ERROR = "IMPLEMENTATION_ERROR", e.ERROR = "ERROR", e.EXPIRED_TOKEN = "EXPIRED_TOKEN", e))(s || {});
+const E = (e) => {
   switch (e) {
     case 401:
       return "EXPIRED_TOKEN";
     default:
       return "NETWORK_ERROR";
   }
-}, a = (e, n) => {
-  const { headers: t = [], method: r = "GET" } = e;
+}, l = (e, r) => {
+  const { headers: t = [], method: n = "GET" } = e;
   return {
-    method: r,
+    method: n,
     mode: "cors",
     cache: "default",
     credentials: "same-origin",
@@ -22,44 +23,44 @@ const s = (e) => {
     redirect: "follow",
     signal: e.signal,
     referrerPolicy: "no-referrer-when-downgrade",
-    ...r === "POST" && n && { body: JSON.stringify(n) }
+    ...n === "POST" && r && { body: JSON.stringify(r) }
   };
 };
-function E({
+function O({
   message: e,
-  level: n,
+  level: r,
   errorCode: t,
-  type: r = "NETWORK_ERROR",
+  type: n = "NETWORK_ERROR",
   requestId: o
 }) {
-  switch (n) {
+  switch (r) {
     case "silent":
       break;
     case "info":
     case "warn":
-      console[n](e);
+      console[r](e);
       break;
     case "error":
     default:
-      throw new c(r, o, e, t);
+      throw new c(n, o, e, t);
   }
 }
-function l(e) {
+function f(e) {
   return e && e.errorCode && e.type && (e.detail || e.invalidFields) && e.status;
 }
-function O(e) {
-  const n = new URLSearchParams();
+function u(e) {
+  const r = 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)));
+    const n = e[t];
+    i(n) || (Array.isArray(n) ? n.forEach((o) => r.append(t, o)) : r.set(t, String(n)));
   }
-  return n;
+  return r;
 }
 export {
-  R as ErrorTypes,
-  s as getErrorType,
-  a as getRequestObject,
-  E as handleFetchError,
-  l as isAdyenErrorResponse,
-  O as parseSearchParams
+  s as ErrorTypes,
+  E as getErrorType,
+  l as getRequestObject,
+  O as handleFetchError,
+  f as isAdyenErrorResponse,
+  u as parseSearchParams
 };