@tonconnect/ui 2.2.0 → 2.3.0-beta.1

package/lib/index.cjs

@@ -18,6 +18,18 @@ var __spreadValues = (a2, b) => {
   return a2;
 };
 var __spreadProps = (a2, b) => __defProps(a2, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
 var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
@@ -83,7 +95,7 @@ function createRoot(fn, detachedOwner) {
     owned: null,
     cleanups: null,
     context: null,
-    owner: detachedOwner === void 0 ? owner : detachedOwner
+    owner: detachedOwner || owner
   }, updateFn = unowned ? fn : () => fn(() => untrack(() => cleanNode(root)));
   Owner = root;
   Listener = null;
@@ -173,9 +185,9 @@ function createResource(pSource, pFetcher, pOptions) {
   }
   function completeLoad(v, err) {
     runUpdates(() => {
-      if (err === void 0)
+      if (!err)
         setValue(() => v);
-      setState(err !== void 0 ? "errored" : "ready");
+      setState(err ? "errored" : "ready");
       setError(err);
       for (const c2 of contexts.keys())
         c2.decrement();
@@ -184,7 +196,7 @@ function createResource(pSource, pFetcher, pOptions) {
   }
   function read() {
     const c2 = SuspenseContext, v = value(), err = error();
-    if (err !== void 0 && !pr)
+    if (err && !pr)
       throw err;
     if (Listener && !Listener.user && c2) {
       createComputed(() => {
@@ -264,8 +276,6 @@ function batch(fn) {
   return runUpdates(fn, false);
 }
 function untrack(fn) {
-  if (Listener === null)
-    return fn();
   const listener = Listener;
   Listener = null;
   try {
@@ -500,9 +510,8 @@ function runUpdates(fn, init) {
     completeUpdates(wait);
     return res;
   } catch (err) {
-    if (!wait)
+    if (!Updates)
       Effects = null;
-    Updates = null;
     handleError(err);
   }
 }
@@ -1825,8 +1834,10 @@ function fixMobileSafariActiveTransition() {
   }
 }
 function defineStylesRoot() {
-  customElements.define(globalStylesTag, class TcRootElement extends HTMLElement {
-  });
+  if (!customElements.get("tc-root")) {
+    customElements.define(globalStylesTag, class TcRootElement extends HTMLElement {
+    });
+  }
 }
 function createMacrotask(callback) {
   return __async(this, null, function* () {
@@ -3034,6 +3045,7 @@ function useDataAttributes(props) {
 const Button = (props) => {
   const dataAttrs = useDataAttributes(props);
   return createComponent(ButtonStyled$1, mergeProps({
+    type: "button",
     get appearance() {
       return props.appearance || "primary";
     },
@@ -4915,16 +4927,16 @@ var qrcode$1 = { exports: {} };
       };
       return _this;
     }();
-    function qrPolynomial(num, shift) {
+    function qrPolynomial(num, shift2) {
       if (typeof num.length == "undefined") {
-        throw num.length + "/" + shift;
+        throw num.length + "/" + shift2;
       }
       var _num = function() {
         var offset = 0;
         while (offset < num.length && num[offset] == 0) {
           offset += 1;
         }
-        var _num2 = new Array(num.length - offset + shift);
+        var _num2 = new Array(num.length - offset + shift2);
         for (var i2 = 0; i2 < num.length - offset; i2 += 1) {
           _num2[i2] = num[i2 + offset];
         }
@@ -7298,18 +7310,18 @@ const NotificationsStyled = styled(Notifications)`
         margin-top: 20px;
     }
 `;
-function getSide(placement) {
-  return placement.split("-")[0];
-}
 function getAlignment(placement) {
   return placement.split("-")[1];
 }
-function getMainAxisFromPlacement(placement) {
-  return ["top", "bottom"].includes(getSide(placement)) ? "x" : "y";
-}
 function getLengthFromAxis(axis) {
   return axis === "y" ? "height" : "width";
 }
+function getSide(placement) {
+  return placement.split("-")[0];
+}
+function getMainAxisFromPlacement(placement) {
+  return ["top", "bottom"].includes(getSide(placement)) ? "x" : "y";
+}
 function computeCoordsFromPlacement(_ref, placement, rtl) {
   let {
     reference,
@@ -7465,6 +7477,22 @@ const computePosition$1 = (reference, floating, config) => __async(exports, null
     middlewareData
   };
 });
+function expandPaddingObject(padding) {
+  return __spreadValues({
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0
+  }, padding);
+}
+function getSideObjectFromPadding(padding) {
+  return typeof padding !== "number" ? expandPaddingObject(padding) : {
+    top: padding,
+    right: padding,
+    bottom: padding,
+    left: padding
+  };
+}
 function rectToClientRect(rect) {
   return __spreadProps(__spreadValues({}, rect), {
     top: rect.y,
@@ -7473,6 +7501,305 @@ function rectToClientRect(rect) {
     bottom: rect.y + rect.height
   });
 }
+function detectOverflow(middlewareArguments, options) {
+  return __async(this, null, function* () {
+    var _await$platform$isEle;
+    if (options === void 0) {
+      options = {};
+    }
+    const {
+      x,
+      y,
+      platform: platform2,
+      rects,
+      elements,
+      strategy
+    } = middlewareArguments;
+    const {
+      boundary = "clippingAncestors",
+      rootBoundary = "viewport",
+      elementContext = "floating",
+      altBoundary = false,
+      padding = 0
+    } = options;
+    const paddingObject = getSideObjectFromPadding(padding);
+    const altContext = elementContext === "floating" ? "reference" : "floating";
+    const element = elements[altBoundary ? altContext : elementContext];
+    const clippingClientRect = rectToClientRect(yield platform2.getClippingRect({
+      element: ((_await$platform$isEle = yield platform2.isElement == null ? void 0 : platform2.isElement(element)) != null ? _await$platform$isEle : true) ? element : element.contextElement || (yield platform2.getDocumentElement == null ? void 0 : platform2.getDocumentElement(elements.floating)),
+      boundary,
+      rootBoundary,
+      strategy
+    }));
+    const rect = elementContext === "floating" ? __spreadProps(__spreadValues({}, rects.floating), {
+      x,
+      y
+    }) : rects.reference;
+    const offsetParent = yield platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(elements.floating);
+    const offsetScale = (yield platform2.isElement == null ? void 0 : platform2.isElement(offsetParent)) ? (yield platform2.getScale == null ? void 0 : platform2.getScale(offsetParent)) || {
+      x: 1,
+      y: 1
+    } : {
+      x: 1,
+      y: 1
+    };
+    const elementClientRect = rectToClientRect(platform2.convertOffsetParentRelativeRectToViewportRelativeRect ? yield platform2.convertOffsetParentRelativeRectToViewportRelativeRect({
+      rect,
+      offsetParent,
+      strategy
+    }) : rect);
+    return {
+      top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
+      bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
+      left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
+      right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
+    };
+  });
+}
+const min$1 = Math.min;
+const max$1 = Math.max;
+function within(min$1$1, value, max$1$1) {
+  return max$1(min$1$1, min$1(value, max$1$1));
+}
+const oppositeSideMap = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+};
+function getOppositePlacement(placement) {
+  return placement.replace(/left|right|bottom|top/g, (side) => oppositeSideMap[side]);
+}
+function getAlignmentSides(placement, rects, rtl) {
+  if (rtl === void 0) {
+    rtl = false;
+  }
+  const alignment = getAlignment(placement);
+  const mainAxis = getMainAxisFromPlacement(placement);
+  const length = getLengthFromAxis(mainAxis);
+  let mainAlignmentSide = mainAxis === "x" ? alignment === (rtl ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top";
+  if (rects.reference[length] > rects.floating[length]) {
+    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
+  }
+  return {
+    main: mainAlignmentSide,
+    cross: getOppositePlacement(mainAlignmentSide)
+  };
+}
+const oppositeAlignmentMap = {
+  start: "end",
+  end: "start"
+};
+function getOppositeAlignmentPlacement(placement) {
+  return placement.replace(/start|end/g, (alignment) => oppositeAlignmentMap[alignment]);
+}
+function getExpandedPlacements(placement) {
+  const oppositePlacement = getOppositePlacement(placement);
+  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
+}
+function getSideList(side, isStart, rtl) {
+  const lr = ["left", "right"];
+  const rl = ["right", "left"];
+  const tb = ["top", "bottom"];
+  const bt = ["bottom", "top"];
+  switch (side) {
+    case "top":
+    case "bottom":
+      if (rtl)
+        return isStart ? rl : lr;
+      return isStart ? lr : rl;
+    case "left":
+    case "right":
+      return isStart ? tb : bt;
+    default:
+      return [];
+  }
+}
+function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
+  const alignment = getAlignment(placement);
+  let list = getSideList(getSide(placement), direction === "start", rtl);
+  if (alignment) {
+    list = list.map((side) => side + "-" + alignment);
+    if (flipAlignment) {
+      list = list.concat(list.map(getOppositeAlignmentPlacement));
+    }
+  }
+  return list;
+}
+const flip = function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: "flip",
+    options,
+    fn(middlewareArguments) {
+      return __async(this, null, function* () {
+        var _middlewareData$flip;
+        const {
+          placement,
+          middlewareData,
+          rects,
+          initialPlacement,
+          platform: platform2,
+          elements
+        } = middlewareArguments;
+        const _a3 = options, {
+          mainAxis: checkMainAxis = true,
+          crossAxis: checkCrossAxis = true,
+          fallbackPlacements: specifiedFallbackPlacements,
+          fallbackStrategy = "bestFit",
+          fallbackAxisSideDirection = "none",
+          flipAlignment = true
+        } = _a3, detectOverflowOptions = __objRest(_a3, [
+          "mainAxis",
+          "crossAxis",
+          "fallbackPlacements",
+          "fallbackStrategy",
+          "fallbackAxisSideDirection",
+          "flipAlignment"
+        ]);
+        const side = getSide(placement);
+        const isBasePlacement = getSide(initialPlacement) === initialPlacement;
+        const rtl = yield platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating);
+        const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
+        if (!specifiedFallbackPlacements && fallbackAxisSideDirection !== "none") {
+          fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
+        }
+        const placements = [initialPlacement, ...fallbackPlacements];
+        const overflow = yield detectOverflow(middlewareArguments, detectOverflowOptions);
+        const overflows = [];
+        let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
+        if (checkMainAxis) {
+          overflows.push(overflow[side]);
+        }
+        if (checkCrossAxis) {
+          const {
+            main,
+            cross
+          } = getAlignmentSides(placement, rects, rtl);
+          overflows.push(overflow[main], overflow[cross]);
+        }
+        overflowsData = [...overflowsData, {
+          placement,
+          overflows
+        }];
+        if (!overflows.every((side2) => side2 <= 0)) {
+          var _middlewareData$flip2;
+          const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
+          const nextPlacement = placements[nextIndex];
+          if (nextPlacement) {
+            return {
+              data: {
+                index: nextIndex,
+                overflows: overflowsData
+              },
+              reset: {
+                placement: nextPlacement
+              }
+            };
+          }
+          let resetPlacement = "bottom";
+          switch (fallbackStrategy) {
+            case "bestFit": {
+              var _overflowsData$map$so;
+              const placement2 = (_overflowsData$map$so = overflowsData.map((d) => [d, d.overflows.filter((overflow2) => overflow2 > 0).reduce((acc, overflow2) => acc + overflow2, 0)]).sort((a2, b) => a2[1] - b[1])[0]) == null ? void 0 : _overflowsData$map$so[0].placement;
+              if (placement2) {
+                resetPlacement = placement2;
+              }
+              break;
+            }
+            case "initialPlacement":
+              resetPlacement = initialPlacement;
+              break;
+          }
+          if (placement !== resetPlacement) {
+            return {
+              reset: {
+                placement: resetPlacement
+              }
+            };
+          }
+        }
+        return {};
+      });
+    }
+  };
+};
+function getCrossAxis(axis) {
+  return axis === "x" ? "y" : "x";
+}
+const shift = function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: "shift",
+    options,
+    fn(middlewareArguments) {
+      return __async(this, null, function* () {
+        const {
+          x,
+          y,
+          placement
+        } = middlewareArguments;
+        const _a3 = options, {
+          mainAxis: checkMainAxis = true,
+          crossAxis: checkCrossAxis = false,
+          limiter = {
+            fn: (_ref) => {
+              let {
+                x: x2,
+                y: y2
+              } = _ref;
+              return {
+                x: x2,
+                y: y2
+              };
+            }
+          }
+        } = _a3, detectOverflowOptions = __objRest(_a3, [
+          "mainAxis",
+          "crossAxis",
+          "limiter"
+        ]);
+        const coords = {
+          x,
+          y
+        };
+        const overflow = yield detectOverflow(middlewareArguments, detectOverflowOptions);
+        const mainAxis = getMainAxisFromPlacement(getSide(placement));
+        const crossAxis = getCrossAxis(mainAxis);
+        let mainAxisCoord = coords[mainAxis];
+        let crossAxisCoord = coords[crossAxis];
+        if (checkMainAxis) {
+          const minSide = mainAxis === "y" ? "top" : "left";
+          const maxSide = mainAxis === "y" ? "bottom" : "right";
+          const min2 = mainAxisCoord + overflow[minSide];
+          const max2 = mainAxisCoord - overflow[maxSide];
+          mainAxisCoord = within(min2, mainAxisCoord, max2);
+        }
+        if (checkCrossAxis) {
+          const minSide = crossAxis === "y" ? "top" : "left";
+          const maxSide = crossAxis === "y" ? "bottom" : "right";
+          const min2 = crossAxisCoord + overflow[minSide];
+          const max2 = crossAxisCoord - overflow[maxSide];
+          crossAxisCoord = within(min2, crossAxisCoord, max2);
+        }
+        const limitedCoords = limiter.fn(__spreadProps(__spreadValues({}, middlewareArguments), {
+          [mainAxis]: mainAxisCoord,
+          [crossAxis]: crossAxisCoord
+        }));
+        return __spreadProps(__spreadValues({}, limitedCoords), {
+          data: {
+            x: limitedCoords.x - x,
+            y: limitedCoords.y - y
+          }
+        });
+      });
+    }
+  };
+};
 function getWindow(node) {
   var _node$ownerDocument;
   return ((_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
@@ -7518,7 +7845,7 @@ function isOverflowElement(element) {
     overflowY,
     display
   } = getComputedStyle$1(element);
-  return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX) && !["inline", "contents"].includes(display);
+  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !["inline", "contents"].includes(display);
 }
 function isTableElement(element) {
   return ["table", "td", "th"].includes(getNodeName(element));
@@ -7543,28 +7870,43 @@ function isLastTraversableNode(node) {
 const min = Math.min;
 const max = Math.max;
 const round = Math.round;
+function getCssDimensions(element) {
+  const css = getComputedStyle$1(element);
+  let width = parseFloat(css.width);
+  let height = parseFloat(css.height);
+  const offsetWidth = element.offsetWidth;
+  const offsetHeight = element.offsetHeight;
+  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
+  if (shouldFallback) {
+    width = offsetWidth;
+    height = offsetHeight;
+  }
+  return {
+    width,
+    height,
+    fallback: shouldFallback
+  };
+}
+function unwrapElement(element) {
+  return !isElement(element) ? element.contextElement : element;
+}
 const FALLBACK_SCALE = {
   x: 1,
   y: 1
 };
 function getScale(element) {
-  const domElement = !isElement(element) && element.contextElement ? element.contextElement : isElement(element) ? element : null;
-  if (!domElement) {
+  const domElement = unwrapElement(element);
+  if (!isHTMLElement(domElement)) {
     return FALLBACK_SCALE;
   }
   const rect = domElement.getBoundingClientRect();
-  const css = getComputedStyle$1(domElement);
-  if (css.boxSizing !== "border-box") {
-    if (!isHTMLElement(domElement)) {
-      return FALLBACK_SCALE;
-    }
-    return {
-      x: domElement.offsetWidth > 0 ? round(rect.width) / domElement.offsetWidth || 1 : 1,
-      y: domElement.offsetHeight > 0 ? round(rect.height) / domElement.offsetHeight || 1 : 1
-    };
-  }
-  let x = rect.width / parseFloat(css.width);
-  let y = rect.height / parseFloat(css.height);
+  const {
+    width,
+    height,
+    fallback
+  } = getCssDimensions(domElement);
+  let x = (fallback ? round(rect.width) : rect.width) / width;
+  let y = (fallback ? round(rect.height) : rect.height) / height;
   if (!x || !Number.isFinite(x)) {
     x = 1;
   }
@@ -7577,7 +7919,7 @@ function getScale(element) {
   };
 }
 function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
-  var _win$visualViewport$o, _win$visualViewport, _win$visualViewport$o2, _win$visualViewport2;
+  var _win$visualViewport, _win$visualViewport2;
   if (includeScale === void 0) {
     includeScale = false;
   }
@@ -7585,6 +7927,7 @@ function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetPar
     isFixedStrategy = false;
   }
   const clientRect = element.getBoundingClientRect();
+  const domElement = unwrapElement(element);
   let scale = FALLBACK_SCALE;
   if (includeScale) {
     if (offsetParent) {
@@ -7595,12 +7938,31 @@ function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetPar
       scale = getScale(element);
     }
   }
-  const win = isElement(element) ? getWindow(element) : window;
+  const win = domElement ? getWindow(domElement) : window;
   const addVisualOffsets = !isLayoutViewport() && isFixedStrategy;
-  const x = (clientRect.left + (addVisualOffsets ? (_win$visualViewport$o = (_win$visualViewport = win.visualViewport) == null ? void 0 : _win$visualViewport.offsetLeft) != null ? _win$visualViewport$o : 0 : 0)) / scale.x;
-  const y = (clientRect.top + (addVisualOffsets ? (_win$visualViewport$o2 = (_win$visualViewport2 = win.visualViewport) == null ? void 0 : _win$visualViewport2.offsetTop) != null ? _win$visualViewport$o2 : 0 : 0)) / scale.y;
-  const width = clientRect.width / scale.x;
-  const height = clientRect.height / scale.y;
+  let x = (clientRect.left + (addVisualOffsets ? ((_win$visualViewport = win.visualViewport) == null ? void 0 : _win$visualViewport.offsetLeft) || 0 : 0)) / scale.x;
+  let y = (clientRect.top + (addVisualOffsets ? ((_win$visualViewport2 = win.visualViewport) == null ? void 0 : _win$visualViewport2.offsetTop) || 0 : 0)) / scale.y;
+  let width = clientRect.width / scale.x;
+  let height = clientRect.height / scale.y;
+  if (domElement) {
+    const win2 = getWindow(domElement);
+    const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
+    let currentIFrame = win2.frameElement;
+    while (currentIFrame && offsetParent && offsetWin !== win2) {
+      const iframeScale = getScale(currentIFrame);
+      const iframeRect = currentIFrame.getBoundingClientRect();
+      const css = getComputedStyle(currentIFrame);
+      iframeRect.x += (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
+      iframeRect.y += (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
+      x *= iframeScale.x;
+      y *= iframeScale.y;
+      width *= iframeScale.x;
+      height *= iframeScale.y;
+      x += iframeRect.x;
+      y += iframeRect.y;
+      currentIFrame = getWindow(currentIFrame).frameElement;
+    }
+  }
   return {
     width,
     height,
@@ -7697,17 +8059,7 @@ function getOffsetParent(element) {
   return offsetParent || getContainingBlock(element) || window2;
 }
 function getDimensions(element) {
-  if (isHTMLElement(element)) {
-    return {
-      width: element.offsetWidth,
-      height: element.offsetHeight
-    };
-  }
-  const rect = getBoundingClientRect(element);
-  return {
-    width: rect.width,
-    height: rect.height
-  };
+  return getCssDimensions(element);
 }
 function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
   let {
@@ -8055,7 +8407,8 @@ const AccountButton = () => {
   const [anchor, setAnchor] = createSignal();
   const position = P(anchor, floating, {
     whileElementsMounted: autoUpdate,
-    placement: "bottom-end"
+    placement: "bottom-end",
+    middleware: [flip(), shift()]
   });
   const normalizedAddress = () => {
     const acc = account();
@@ -12157,7 +12510,7 @@ class TonConnectUITracker {
     }
   }
 }
-const tonConnectUiVersion = "2.2.0";
+const tonConnectUiVersion = "2.3.0-beta.1";
 class TonConnectUI {
   constructor(options) {
     __publicField(this, "walletInfoStorage", new WalletInfoStorage());
@@ -12393,6 +12746,7 @@ class TonConnectUI {
       });
       const abortController = new AbortController();
       const onRequestSent = () => {
+        var _a2;
         if (abortController.signal.aborted) {
           return;
         }
@@ -12406,6 +12760,20 @@ class TonConnectUI {
           returnStrategy,
           twaReturnUrl
         });
+        let firstClick = true;
+        const redirectToWallet2 = () => {
+          if (abortController.signal.aborted) {
+            return;
+          }
+          const forceRedirect = !firstClick;
+          firstClick = false;
+          this.redirectAfterRequestSent({
+            returnStrategy,
+            twaReturnUrl,
+            forceRedirect
+          });
+        };
+        (_a2 = options == null ? void 0 : options.onRequestSent) == null ? void 0 : _a2.call(options, redirectToWallet2);
       };
       const unsubscribe = this.onTransactionModalStateChange((action2) => {
         if (action2 == null ? void 0 : action2.openModal) {
@@ -12453,7 +12821,7 @@ class TonConnectUI {
       }
     });
   }
-  signData(data) {
+  signData(data, options) {
     return __async(this, null, function* () {
       this.tracker.trackDataSentForSignature(this.wallet, data);
       if (!this.connected) {
@@ -12472,6 +12840,7 @@ class TonConnectUI {
       });
       const abortController = new AbortController();
       const onRequestSent = () => {
+        var _a2;
         if (abortController.signal.aborted) {
           return;
         }
@@ -12485,6 +12854,20 @@ class TonConnectUI {
           returnStrategy,
           twaReturnUrl
         });
+        let firstClick = true;
+        const redirectToWallet2 = () => {
+          if (abortController.signal.aborted) {
+            return;
+          }
+          const forceRedirect = !firstClick;
+          firstClick = false;
+          this.redirectAfterRequestSent({
+            returnStrategy,
+            twaReturnUrl,
+            forceRedirect
+          });
+        };
+        (_a2 = options == null ? void 0 : options.onRequestSent) == null ? void 0 : _a2.call(options, redirectToWallet2);
       };
       const unsubscribe = this.onTransactionModalStateChange((action2) => {
         if (action2 == null ? void 0 : action2.openModal) {
@@ -12534,14 +12917,15 @@ class TonConnectUI {
   }
   redirectAfterRequestSent({
     returnStrategy,
-    twaReturnUrl
+    twaReturnUrl,
+    forceRedirect
   }) {
     if (this.walletInfo && "universalLink" in this.walletInfo && (this.walletInfo.openMethod === "universal-link" || this.walletInfo.openMethod === "custom-deeplink")) {
       if (sdk.isTelegramUrl(this.walletInfo.universalLink)) {
         redirectToTelegram(this.walletInfo.universalLink, {
           returnStrategy,
           twaReturnUrl: twaReturnUrl || appState.twaReturnUrl,
-          forceRedirect: false
+          forceRedirect: forceRedirect || false
         });
       } else {
         redirectToWallet(
@@ -12549,7 +12933,7 @@ class TonConnectUI {
           this.walletInfo.deepLink,
           {
             returnStrategy,
-            forceRedirect: false
+            forceRedirect: forceRedirect || false
           },
           () => {
           }