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

package/dist/es/primitives/async/abortable/main.js

@@ -0,0 +1,26 @@
+import { struct as l } from "../../../utils/struct/main.js";
+import { enumerable as n, getter as s } from "../../../utils/struct/property.js";
+import { isUndefined as d } from "../../../utils/value/is.js";
+import { noop as p } from "../../../utils/common.js";
+const w = (o) => {
+  let r, e, t;
+  const a = () => {
+    r == null || r.abort(), r = void 0;
+  }, m = () => (t = new Promise((u, f) => {
+    if (e.addEventListener("abort", function c() {
+      e.removeEventListener("abort", c), f(o);
+    }), e.aborted)
+      throw o;
+  }), t.catch(p), t), i = () => (d(r) && (r = new AbortController(), e = r.signal, t = m()), b), b = l({
+    abort: n(a),
+    promise: s(() => t),
+    reason: n(o),
+    refresh: n(i),
+    signal: s(() => e)
+  });
+  return i();
+};
+export {
+  w as createAbortable,
+  w as default
+};

package/dist/es/primitives/async/deferred/main.js

@@ -0,0 +1,22 @@
+import { struct as l } from "../../../utils/struct/main.js";
+import { getter as p, enumerable as t } from "../../../utils/struct/property.js";
+import { noop as u } from "../../../utils/common.js";
+const _ = () => {
+  let o, s, r;
+  const m = () => {
+    const e = r ?? u, c = new Promise((f, i) => {
+      r = f, s = i;
+    });
+    return e(o = c), n;
+  }, n = l({
+    promise: p(() => o),
+    refresh: t(m),
+    reject: t((e) => s(e)),
+    resolve: t((e) => r(e))
+  });
+  return m();
+};
+export {
+  _ as createDeferred,
+  _ as default
+};

package/dist/es/primitives/async/promisor/main.js

@@ -0,0 +1,31 @@
+import { createAbortable as c } from "../abortable/main.js";
+import { createDeferred as n } from "../deferred/main.js";
+import { tryResolve as l } from "../../../utils/async/main.js";
+import { enumerable as a, getter as p } from "../../../utils/struct/property.js";
+import { isUndefined as b } from "../../../utils/value/is.js";
+const _ = (m) => {
+  let e;
+  const o = c(Symbol()), r = n();
+  return Object.defineProperties(function(...f) {
+    b(e) && r.refresh(), o.abort(), o.refresh(), e = l.call(this, m, o.signal, ...f);
+    let t;
+    const s = e;
+    return (async () => {
+      try {
+        const i = await s;
+        t = () => r.resolve(i);
+      } catch (i) {
+        t = () => r.reject(i);
+      }
+      e === s && (e = void 0, t());
+    })(), s;
+  }, {
+    abort: a(() => o.abort()),
+    promise: p(() => r.promise),
+    refresh: a(() => void r.refresh())
+  });
+};
+export {
+  _ as createPromisor,
+  _ as default
+};

package/dist/es/primitives/auxiliary/abortSink/main.js

@@ -0,0 +1,42 @@
+import { struct as v } from "../../../utils/struct/main.js";
+import { enumerable as a } from "../../../utils/struct/property.js";
+import { noop as b } from "../../../utils/common.js";
+const m = "abort", d = (l) => l instanceof AbortSignal, u = (...l) => {
+  let r = /* @__PURE__ */ new Set(), f = new AbortController();
+  const { signal: c } = f;
+  let t = () => {
+    f.abort(), o == null || o();
+  }, n = () => {
+    r.forEach((e) => e.removeEventListener(m, t)), r.clear(), r = void 0;
+  }, o = () => {
+    n == null || n(), n = i = void 0, c.aborted && (t = f = o = void 0);
+  }, i = (...e) => {
+    for (const s of e)
+      d(s) && r.delete(s) && s.removeEventListener(m, t);
+    r.size === 0 && o();
+  };
+  e: {
+    o: {
+      for (const e of l)
+        if (d(e)) {
+          if (e.aborted)
+            break o;
+          r.add(e);
+        }
+      r.size > 0 ? r.forEach((e) => e.addEventListener(m, t)) : o();
+      break e;
+    }
+    t();
+  }
+  return v({
+    abort: a(t ? () => t == null ? void 0 : t() : b),
+    disconnect: a(o ? () => o == null ? void 0 : o() : b),
+    signal: a(c),
+    unlink: a(i ? (...e) => i == null ? void 0 : i(...e) : b)
+  });
+};
+export {
+  u as createAbortSink,
+  u as default,
+  d as isAbortSignal
+};

package/dist/es/primitives/auxiliary/errorContainer/main.js

@@ -0,0 +1,26 @@
+import { struct as E } from "../../../utils/struct/main.js";
+import { getter as o, enumerable as s } from "../../../utils/struct/property.js";
+const e = Symbol("<<NO_ERR>>");
+function c(r) {
+  /* istanbul ignore if -- @preserve */
+  if (r === e)
+    throw new TypeError("Illegal error");
+}
+const i = () => {
+  let r = e;
+  const n = () => {
+    r = e;
+  }, a = (t) => {
+    c(t), r = t;
+  };
+  return E({
+    error: o(() => r === e ? void 0 : r),
+    hasError: o(() => r !== e),
+    reset: s(n),
+    set: s(a)
+  });
+};
+export {
+  i as createErrorContainer,
+  i as default
+};

package/dist/es/primitives/auxiliary/indexed/helpers.js

@@ -0,0 +1,17 @@
+import { isString as r } from "../../../utils/value/is.js";
+import { identity as c } from "../../../utils/common.js";
+const s = (e) => (i, t, o) => {
+  if (r(t)) {
+    const n = +t;
+    if (n >= 0 && n < i.length)
+      return e(n);
+  }
+  return Reflect.get(i, t, o);
+}, d = function* (e = c, i) {
+  for (let t = 0; t < this.length; t++)
+    yield e.call(i, this[t], t, this);
+};
+export {
+  s as indexedProxyGetTrap,
+  d as mapIteratorFactory
+};

package/dist/es/primitives/auxiliary/indexed/main.js

@@ -0,0 +1,35 @@
+import { mapIteratorFactory as m, indexedProxyGetTrap as f } from "./helpers.js";
+import { truthify as o } from "../../../utils/value/bool.js";
+import { struct as a, structFrom as c } from "../../../utils/struct/main.js";
+import { isFunction as d, isNumber as h } from "../../../utils/value/is.js";
+const l = Object.freeze(
+  a({
+    [Symbol.iterator]: {
+      value() {
+        return m.call(this);
+      }
+    },
+    map: {
+      value(t, n) {
+        return [...m.call(this, t, n)];
+      }
+    }
+  })
+), u = (t, n) => d(t) ? u(
+  {
+    length: { get: t }
+  },
+  n
+) : h(t) ? u(
+  {
+    length: { value: t }
+  },
+  n
+) : new Proxy(c(l, t), {
+  get: f(n),
+  set: o
+});
+export {
+  u as createIndexed,
+  u as default
+};

package/dist/es/primitives/context/session/SessionContext.js

@@ -0,0 +1,141 @@
+var E = Object.defineProperty;
+var d = (r, s, e) => s in r ? E(r, s, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[s] = e;
+var i = (r, s, e) => (d(r, typeof s != "symbol" ? s + "" : s, e), e);
+import { ERR_SESSION_REFRESH_ABORTED as u, ERR_SESSION_INVALID as R, ERR_SESSION_FACTORY_UNAVAILABLE as b, ERR_SESSION_HTTP_UNAVAILABLE as A, EVT_SESSION_EXPIRED_STATE_CHANGE as c, EVT_SESSION_REFRESHING_STATE_CHANGE as p, ERR_SESSION_EXPIRED as g } from "./constants.js";
+import { createEventEmitter as P } from "../../reactive/eventEmitter/main.js";
+import { createAbortable as y } from "../../async/abortable/main.js";
+import { createPromisor as x } from "../../async/promisor/main.js";
+import { falsify as w, boolOrFalse as h } from "../../../utils/value/bool.js";
+import { ALREADY_RESOLVED_PROMISE as m } from "../../../utils/async/constants.js";
+import { parseDate as I } from "../../../utils/datetime/main.js";
+import v from "../../time/clock/main.js";
+import { isWatchlistUnsubscribeToken as T } from "../../reactive/watchlist/main.js";
+import { isFunction as _, isUndefined as l } from "../../../utils/value/is.js";
+import { tryResolve as N } from "../../../utils/async/main.js";
+import { noop as S } from "../../../utils/common.js";
+class M {
+  constructor(s) {
+    i(this, "_expired", !1);
+    i(this, "_refreshing", !1);
+    i(this, "_refreshCount", 0);
+    i(this, "_refreshEventPending", !1);
+    i(this, "_refreshingPromise");
+    i(this, "_refreshPending", !1);
+    i(this, "_session");
+    i(this, "_sessionActivationTimestamp");
+    i(this, "_sessionExpirationTimestamp");
+    i(this, "_stopSessionClock");
+    i(this, "_eventEmitter", P());
+    i(this, "_refreshAbortable", y(u));
+    i(this, "_sessionPromisor", x(function(s, e) {
+      return this._expired = this._refreshPending = !1, this._eventEmitter.emit(c), e;
+    }));
+    this._specification = s, this.http = this._sessionHttp.bind(this), this.on = this._eventEmitter.on, this.refresh = this._refreshSession.bind(this);
+  }
+  get isExpired() {
+    return this._sessionIsExpired();
+  }
+  get refreshing() {
+    return this._refreshing;
+  }
+  get timestamp() {
+    return this._sessionActivationTimestamp;
+  }
+  _assertRefreshNotInterruptedByAbort(s, e = Symbol()) {
+    if (this._refreshInterruptedByAbort(s, e))
+      throw this._refreshAbortable.reason;
+  }
+  _assertSession(s) {
+    var e, t;
+    try {
+      (t = (e = this._specification).assert) == null || t.call(e, s);
+    } catch {
+      throw R;
+    }
+  }
+  _assertSessionFactory(s) {
+    if (!_(s))
+      throw b;
+  }
+  _assertSessionHttp(s) {
+    if (!_(s))
+      throw A;
+  }
+  async _canFulfillPendingSessionRefresh() {
+    const s = await N(async () => {
+      const e = this._specification.autoRefresh;
+      return _(e) ? e.call(this._specification, this._session) : e;
+    }).catch(w);
+    return h(s);
+  }
+  async _fulfillPendingSessionRefresh(s = !1) {
+    !h(s) && !await this._canFulfillPendingSessionRefresh() || !this._refreshPending || this._refreshCount > 0 || this._refreshSession().catch(S);
+  }
+  async _getNextSession(s) {
+    this._assertSessionFactory(this._specification.onRefresh);
+    const e = await this._specification.onRefresh(this._session, s);
+    return this._assertRefreshNotInterruptedByAbort(s), this._assertSession(e), e;
+  }
+  _onSessionExpired(s = !1) {
+    var e;
+    this._refreshPending || ((e = this._stopSessionClock) == null || e.call(this), this._expired = this._refreshPending = !0, this._eventEmitter.emit(c), h(s) && this._fulfillPendingSessionRefresh().catch(S));
+  }
+  _refreshInterruptedByAbort(s, e) {
+    return e === this._refreshAbortable.reason || s.aborted;
+  }
+  async _refreshSession() {
+    this._sessionPromisor.refresh(), this._refreshAbortable.abort(), this._refreshAbortable.refresh(), this._refreshCount++;
+    const s = this._refreshAbortable.signal;
+    await (this._refreshingPromise ?? (this._refreshingPromise = (async () => {
+      this._refreshing || (this._refreshing = !0, this._refreshEventPending && await m, this._eventEmitter.emit(p));
+    })()));
+    try {
+      const e = await Promise.race([this._getNextSession(s), this._refreshAbortable.promise]).catch((t) => {
+        throw this._assertRefreshNotInterruptedByAbort(s, t), t;
+      });
+      this._assertRefreshNotInterruptedByAbort(s), await this._setupSessionClock(e), await this._sessionPromisor(this._session = e);
+    } finally {
+      !s.aborted && this._refreshing && (this._refreshEventPending = !0, this._refreshingPromise = void 0, this._refreshing = !1, this._refreshCount = 0, await m, this._refreshEventPending = !1, this._eventEmitter.emit(p));
+    }
+  }
+  async _sessionHttp(...s) {
+    for (await this._fulfillPendingSessionRefresh(!0); ; )
+      try {
+        const e = await this._sessionPromisor.promise;
+        return this._assertSessionHttp(this._specification.http), await this._specification.http(e, this._refreshAbortable.signal, ...s);
+      } catch (e) {
+        if (e !== g)
+          throw e;
+        this._onSessionExpired(!0);
+      }
+  }
+  _sessionIsExpired() {
+    return this._expired || this._verifyPassedSessionDeadline() && this._expired;
+  }
+  async _setupSessionClock(s) {
+    var e, t, o;
+    try {
+      if (this._sessionActivationTimestamp = Date.now(), this._sessionExpirationTimestamp = void 0, this._sessionExpirationTimestamp = I(await ((t = (e = this._specification).deadline) == null ? void 0 : t.call(e, s))), l(this._sessionExpirationTimestamp))
+        return;
+      (o = this._stopSessionClock) == null || o.call(this);
+      let n = v.subscribe((a) => {
+        var f;
+        if (T(a))
+          return (f = this._stopSessionClock) == null ? void 0 : f.call(this);
+        this._verifyPassedSessionDeadline(a.now) && this._fulfillPendingSessionRefresh();
+      });
+      this._stopSessionClock = () => {
+        n == null || n(), n = this._stopSessionClock = void 0;
+      };
+    } catch {
+    }
+  }
+  _verifyPassedSessionDeadline(s = Date.now()) {
+    if (!l(this._sessionExpirationTimestamp))
+      return s >= this._sessionExpirationTimestamp && this._onSessionExpired(), !0;
+  }
+}
+export {
+  M as SessionContext,
+  M as default
+};

package/dist/es/primitives/context/session/constants.js

@@ -0,0 +1,10 @@
+const S = Symbol("Error<SESSION_EXPIRED>"), E = Symbol("Error<SESSION_FACTORY_UNAVAILABLE>"), _ = Symbol("Error<SESSION_HTTP_UNAVAILABLE>"), I = Symbol("Error<SESSION_REFRESH_ABORTED>"), R = Symbol("Error<SESSION_INVALID>"), A = "_sessionExpiredStateChange", N = "_sessionRefreshingStateChange";
+export {
+  S as ERR_SESSION_EXPIRED,
+  E as ERR_SESSION_FACTORY_UNAVAILABLE,
+  _ as ERR_SESSION_HTTP_UNAVAILABLE,
+  R as ERR_SESSION_INVALID,
+  I as ERR_SESSION_REFRESH_ABORTED,
+  A as EVT_SESSION_EXPIRED_STATE_CHANGE,
+  N as EVT_SESSION_REFRESHING_STATE_CHANGE
+};

package/dist/es/primitives/dom/tabbableRoot/tabbable.js

@@ -0,0 +1,102 @@
+import { isUndefined as h, isNullish as v, isNumber as R } from "../../../utils/value/is.js";
+import { some as f } from "../../../utils/collection/main.js";
+import { mod as N } from "../../../utils/value/number.js";
+const p = `
+    a[href],
+    audio[controls],
+    video[controls],
+    button,
+    input,
+    select,
+    textarea,
+    [contenteditable],
+    [tabindex]
+`.replace(/\s+/, ""), x = ["contenteditable", "controls", "disabled", "hidden", "href", "inert", "tabindex"], l = /* @__PURE__ */ new Map(), g = (t) => t.tagName === "INPUT", E = (t) => g(t) && t.type === "radio", I = (t) => {
+  const n = t.name, r = t.form, e = l.get(r);
+  let i = e == null ? void 0 : e.get(n);
+  return h(i) && r && (i = r.querySelector(`input[type=radio][name='${n}']:checked`) || null, l.set(r, (e || /* @__PURE__ */ new Map()).set(n, i))), i === t;
+}, w = (t, n) => {
+  for (const r of n)
+    if (r.type !== "attributes") {
+      if (f(r.addedNodes, (e) => e instanceof Element && s(e)) || f(r.removedNodes, (e) => t.includes(e)))
+        return !0;
+    } else {
+      if (s(r.target))
+        return !0;
+      if (t.includes(r.target))
+        return !0;
+    }
+  return !1;
+}, b = (t = document.body, n) => {
+  if (h(t))
+    return !1;
+  if (v(n))
+    return !!document.activeElement && b(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;
+  }
+  return !1;
+}, S = (t) => !// [TODO]: Include all of these checks
+// (1) matches focusable elements selector
+// (2) is disabled element
+// (3) is inert or inert subtree child
+// (4) is hidden input
+// (5) with visibility: hidden
+// (6) is summary of open details element
+// (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) */
+g(t) && t.hidden), s = (t) => !(E(t) && !I(t) || // (1) is not checked radio button
+(t == null ? void 0 : t.tabIndex) < 0 || // (2) has negative tabindex
+!S(t)), A = () => {
+  const t = new MutationObserver((o) => w(n, o) && u()), n = [];
+  let r = -1, e = null;
+  const i = (o) => {
+    var a;
+    if (o < 0)
+      return;
+    const d = Math.min(o, n.length - 1);
+    r !== d && (r = d), (a = n[r]) == null || a.focus();
+  }, u = () => {
+    n.length = 0, e instanceof Element && (e.querySelectorAll(p).forEach((o) => s(o) && n.push(o)), b(e) && (c.current = document.activeElement));
+  }, c = Object.create(null, {
+    current: {
+      get: () => n[r] ?? null,
+      set: (o) => {
+        if (o) {
+          if (!R(o))
+            return i(n.indexOf(o));
+          if (o === ~~o)
+            return i(N(r + o, n.length));
+        }
+      }
+    },
+    root: {
+      get: () => e,
+      set: (o) => {
+        o !== e && (e && t.disconnect(), e = o instanceof Element ? o : null, n.length = 0, e && (t.observe(e, {
+          attributeFilter: x,
+          attributes: !0,
+          childList: !0,
+          subtree: !0
+        }), u()));
+      }
+    },
+    tabbables: { value: n }
+  });
+  return c;
+}, U = A;
+export {
+  p as SELECTORS,
+  U as default,
+  b as focusIsWithin,
+  S as isFocusable,
+  s as isTabbable,
+  A as withTabbableRoot
+};

package/dist/es/primitives/reactive/effectStack/main.js

@@ -0,0 +1,22 @@
+import { struct as l } from "../../../utils/struct/main.js";
+import { enumerable as o } from "../../../utils/struct/property.js";
+const r = Symbol("<<NO_EXCEPTION>>"), u = (n) => {
+  const t = [];
+  return l({
+    bind: o((e) => function(...i) {
+      let c = r;
+      try {
+        return t.push(e), e.call(this, ...i);
+      } catch (a) {
+        throw c = a;
+      } finally {
+        t.pop(), t.length === 0 && c === r && n();
+      }
+    }),
+    effect: o(n)
+  });
+};
+export {
+  u as createEffectStack,
+  u as default
+};

package/dist/es/primitives/reactive/eventEmitter/main.js

@@ -0,0 +1,42 @@
+import { struct as a } from "../../../utils/struct/main.js";
+import { enumerable as e } from "../../../utils/struct/property.js";
+import { isUndefined as d, isFunction as m } from "../../../utils/value/is.js";
+import { noop as f } from "../../../utils/common.js";
+const E = () => {
+  const r = new class extends EventTarget {
+  }(), l = (o, ...t) => {
+    const [n] = t;
+    t.length && d(n) && console.warn(
+      "Unexpected value `undefined` provided for event detail.\n	Turn off this warning by doing either of the following:\n	(1) omit the optional event detail parameter.\n	(2) explicitly pass `null` for the event detail parameter (instead of `undefined`).\n"
+    );
+    const i = new CustomEvent(
+      o,
+      a({
+        bubbles: e(!1),
+        cancelable: e(!1),
+        detail: e(n ?? null)
+      })
+    );
+    return r.dispatchEvent(i);
+  }, s = (o, t) => {
+    if (!m(t))
+      return f;
+    const n = (i) => t.call(
+      null,
+      a({
+        detail: e(i.detail),
+        timeStamp: e(i.timeStamp),
+        type: e(i.type)
+      })
+    );
+    return r.addEventListener(o, n), () => r.removeEventListener(o, n);
+  };
+  return a({
+    emit: e(l),
+    on: e(s)
+  });
+};
+export {
+  E as createEventEmitter,
+  E as default
+};

package/dist/es/primitives/reactive/reflex/helpers.js

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

package/dist/es/primitives/reactive/reflex/main.js

@@ -0,0 +1,68 @@
+import { assertReflexAction as c, unwrap as i } from "./helpers.js";
+import { $globalReflexRegister as x } from "./register.js";
+import { REF as _ } from "./constants.js";
+import { struct as p } from "../../../utils/struct/main.js";
+import { isNullish as b } from "../../../utils/value/is.js";
+import { sameValue as d } from "../../../utils/value/compare.js";
+const v = (n) => {
+  c(n);
+  const r = new WeakMap([[n, 1]]), e = (o) => {
+    if (d(t, o))
+      return;
+    const u = t;
+    n(t = o, u);
+  };
+  let t = null;
+  return Object.defineProperties(e, {
+    [_]: { value: e },
+    actions: {
+      value: p({
+        get: { value: r.get.bind(r) },
+        size: { value: 1 }
+      })
+    },
+    current: {
+      get: () => t,
+      set: e
+    }
+  });
+}, $ = (n = x) => {
+  let r, e = null, t, o = !1;
+  const u = (l) => {
+    r = void 0, e = null, t = l, o = !1;
+  }, m = () => {
+    o || (a(), o = !0);
+  }, a = () => {
+    try {
+      if (!e)
+        return;
+      n.unbind(e, t);
+    } catch {
+    }
+  };
+  return p({
+    action: { get: () => t },
+    reflex: { get: () => r },
+    release: { value: m },
+    update: { value: (l, s) => {
+      c(l), o && u(l);
+      const f = b(s) ? null : s;
+      if (t === l && e === f) {
+        if (r)
+          return;
+      } else if (e) {
+        if (d(i(e), i(f))) {
+          r = n.bind(e, l), a(), t = l;
+          return;
+        }
+        a();
+      }
+      t = l, r = (e = f) ? n.bind(e, t) : v(t);
+    } }
+  });
+};
+export {
+  v as createIsolatedFauxReflex,
+  $ as createReflexContainer,
+  $ as default
+};