@benji-money/connect-sdk 1.0.10 → 1.1.0-beta.2

package/README.md

@@ -90,6 +90,69 @@ The SDK accepts the following configuration options:
 - `onError` (optional): Callback function called when error occurs in the connect flow
 - `onExit` (optional): Callback function called when the user exits the connect flow
 - `onEvent` (optional): Callback function for handling various events
+- `anchor` (optional): Live anchor binding — `HTMLElement`, CSS selector, getter `() => HTMLElement | null`, or ref `{ value: HTMLElement | null }`. Re-resolved on every layout pass. Falls back to centered when missing or invalid. See [Placement](#placement)
+- `placement` (optional): Placement relative to `anchor` — see [Placement](#placement) below
+- `offset` (optional): Pixel gap after placement — `{ top?: number; left?: number }` (default `{ top: 0, left: 0 }`)
+
+### Placement
+
+Placement uses [Floating UI](https://floating-ui.com/docs/computePosition#placement) / CSS logical naming (`start` / `end`). In **LTR** layouts:
+
+| Value | Meaning |
+| ----- | ------- |
+| `center` (default) | Full-viewport backdrop with iframe centered |
+| `bottom-end` | Below the anchor, right edge aligned with anchor's right edge |
+| `bottom-start` | Below the anchor, left edge aligned with anchor's left edge |
+
+**Defaults:**
+
+- No `anchor` → centered modal (unchanged behavior for existing integrations)
+- `anchor` set, no `placement` → `bottom-end`
+- If the anchor is missing or invalid on **initial open**, there is not enough viewport space below, or the viewport is narrower than the iframe (400px + padding), the SDK falls back to centered
+- While the modal is **already open**, a temporarily hidden or detached anchor (e.g. crossing a responsive layout breakpoint) keeps the last anchored position instead of jumping to center; when the anchor becomes visible again, placement re-anchors automatically
+
+**Live anchor bindings** (re-resolved on scroll, resize, and visual viewport changes):
+
+| Form | Example | When to use |
+| ---- | ------- | ----------- |
+| CSS selector | `'#login-btn'` | Stable id on the anchor element |
+| Ref object | `loginButtonRef` (Vue `{ value: el }`) | Anchor may re-render after async work |
+| Getter | `() => document.querySelector('#login-btn')` | Custom lookup |
+| `HTMLElement` | Snapshot at click time | Only when the node will not be replaced before `open()` |
+
+Prefer selector, ref, or getter when the anchor can re-render (e.g. disabled/loading state) before the modal opens. A stale `HTMLElement` snapshot falls back to a centered modal on open instead of clipping to the top-left; while open, resize across breakpoints preserves the last anchored position until the anchor is visible again or the modal is closed.
+
+**Viewport sizing:**
+
+- Design size is **400×645** px (`IFRAME_WIDTH` / `IFRAME_HEIGHT`)
+- **Centered** modals (default, explicit, or fallback) scale down proportionally when the viewport is smaller than the design size so the modal fits with 8px padding on each side
+- **Anchored** popovers use the full design size when width and height checks pass; otherwise they fall back to a scaled centered modal
+- Scroll, resize, and visual viewport changes while open recompute placement and size
+
+**LOGIN popover example** (dropdown under a top-right button):
+
+```typescript
+import {
+  ConnectSDK,
+  BenjiConnectMode,
+  BenjiConnectPlacement,
+} from "@benji-money/connect-sdk";
+
+// Prefer a live binding (selector or ref) when the button may re-render before open()
+const sdk = new ConnectSDK({
+  environment: "sandbox",
+  token: connectToken,
+  mode: BenjiConnectMode.LOGIN,
+  anchor: "#login-btn",
+  placement: BenjiConnectPlacement.BOTTOM_END,
+  offset: { top: 8 },
+  onSuccess: (token) => { /* ... */ },
+});
+
+await sdk.open();
+```
+
+> **`bottom-end`** opens below the anchor with the modal's right edge aligned to the anchor's right edge — matching a dropdown under a top-right LOGIN button.
 
 ### Environments
 

package/dist/connect-sdk.umd.global.js

@@ -110,7 +110,7 @@ var ConnectSDK = (() => {
   // src/utils/config.ts
   var buildContext = () => ({
     namespace: "benji-connect-sdk" ? "benji-connect-sdk" : "benji-connect-sdk",
-    version: "1.0.10" ? String("1.0.10") : "0.0.0"
+    version: "1.1.0-beta.2" ? String("1.1.0-beta.2") : "0.0.0"
   });
   function isBenjiConnectEnvironment(environment) {
     return environment === "local" /* LOCAL */ || environment === "development" /* DEVELOPMENT */ || environment === "sandbox" /* SANDBOX */ || environment === "production" /* PRODUCTION */;
@@ -130,11 +130,312 @@ var ConnectSDK = (() => {
     return defaultEnvironment;
   }
 
+  // src/utils/placement.ts
+  var IFRAME_WIDTH = 400;
+  var IFRAME_HEIGHT = 645;
+  var IFRAME_STATIC_STYLE = {
+    border: "none",
+    borderRadius: "20px",
+    overflow: "hidden"
+  };
+  var CONTAINER_BASE_STYLE = {
+    position: "fixed",
+    top: "0",
+    left: "0",
+    width: "100%",
+    height: "100%",
+    backgroundColor: "rgba(0,0,0,0.5)",
+    zIndex: "9999"
+  };
+  var VIEWPORT_PADDING = 8;
+  function isPreservableAnchoredLayout(layout) {
+    return layout != null && layout.placement !== "center" /* CENTER */;
+  }
+  function clampPreservedAnchoredLayout(layout, viewport) {
+    const maxLeft = viewport.width - layout.width - VIEWPORT_PADDING;
+    const maxTop = viewport.height - layout.height - VIEWPORT_PADDING;
+    const minLeft = VIEWPORT_PADDING;
+    const minTop = VIEWPORT_PADDING;
+    return {
+      ...layout,
+      left: maxLeft < minLeft ? minLeft : Math.min(Math.max(layout.left, minLeft), maxLeft),
+      top: maxTop < minTop ? minTop : Math.min(Math.max(layout.top, minTop), maxTop)
+    };
+  }
+  function preservedAnchoredLayoutOrCenter(viewport, options) {
+    const { preserveAnchoredLayout } = options;
+    if (isPreservableAnchoredLayout(preserveAnchoredLayout)) {
+      return clampPreservedAnchoredLayout(preserveAnchoredLayout, viewport);
+    }
+    return centerLayout(viewport);
+  }
+  function isRefLikeAnchor(anchor) {
+    return typeof anchor === "object" && anchor !== null && !(anchor instanceof HTMLElement) && "value" in anchor;
+  }
+  function resolveAnchor(anchor) {
+    if (!anchor) {
+      return null;
+    }
+    if (typeof anchor === "string") {
+      return document.querySelector(anchor);
+    }
+    if (typeof anchor === "function") {
+      const resolved = anchor();
+      return resolved instanceof HTMLElement ? resolved : null;
+    }
+    if (isRefLikeAnchor(anchor)) {
+      const el = anchor.value;
+      return el instanceof HTMLElement ? el : null;
+    }
+    return anchor instanceof HTMLElement ? anchor : null;
+  }
+  function isAnchorVisible(el) {
+    if (!el.isConnected) {
+      return false;
+    }
+    const style = window.getComputedStyle(el);
+    if (style.display === "none" || style.visibility === "hidden") {
+      return false;
+    }
+    const rect = el.getBoundingClientRect();
+    return rect.width > 0 || rect.height > 0;
+  }
+  function resolveEffectivePlacement(config) {
+    var _a;
+    if (!config.anchor) {
+      return "center" /* CENTER */;
+    }
+    return (_a = config.placement) != null ? _a : "bottom-end" /* BOTTOM_END */;
+  }
+  function defaultOffset(offset) {
+    var _a, _b;
+    return {
+      top: (_a = offset == null ? void 0 : offset.top) != null ? _a : 0,
+      left: (_b = offset == null ? void 0 : offset.left) != null ? _b : 0
+    };
+  }
+  function resolveIframeDimensions(viewport) {
+    const maxW = viewport.width - 2 * VIEWPORT_PADDING;
+    const maxH = viewport.height - 2 * VIEWPORT_PADDING;
+    const scale = Math.min(1, maxW / IFRAME_WIDTH, maxH / IFRAME_HEIGHT);
+    return {
+      width: Math.floor(IFRAME_WIDTH * scale),
+      height: Math.floor(IFRAME_HEIGHT * scale)
+    };
+  }
+  function iframeFitsHorizontally(viewportWidth, iframeWidth = IFRAME_WIDTH) {
+    return viewportWidth >= iframeWidth + 2 * VIEWPORT_PADDING;
+  }
+  function centerLayout(viewport) {
+    const { width, height } = resolveIframeDimensions(viewport);
+    return {
+      top: 0,
+      left: 0,
+      width,
+      height,
+      placement: "center" /* CENTER */
+    };
+  }
+  function fitsBelow(anchorBottom, offsetTop, viewportHeight, iframeHeight = IFRAME_HEIGHT) {
+    const top = anchorBottom + offsetTop;
+    const bottom = top + iframeHeight;
+    return top >= VIEWPORT_PADDING && bottom <= viewportHeight - VIEWPORT_PADDING;
+  }
+  function clampHorizontal(left, viewportWidth) {
+    const min = VIEWPORT_PADDING;
+    const max = viewportWidth - IFRAME_WIDTH - VIEWPORT_PADDING;
+    if (max < min) {
+      return min;
+    }
+    return Math.min(Math.max(left, min), max);
+  }
+  function warnInvalidAnchor(message) {
+    console.warn(`[Benji Connect SDK] ${message}`);
+  }
+  function computeIframeRect(anchorElement, placement, offset, viewport, options = {}) {
+    const { warnOnInvalidAnchor = false } = options;
+    const resolvedOffset = defaultOffset(offset);
+    if (placement === "center" /* CENTER */) {
+      return centerLayout(viewport);
+    }
+    if (!isAnchorVisible(anchorElement)) {
+      if (isPreservableAnchoredLayout(options.preserveAnchoredLayout)) {
+        return clampPreservedAnchoredLayout(
+          options.preserveAnchoredLayout,
+          viewport
+        );
+      }
+      if (warnOnInvalidAnchor) {
+        warnInvalidAnchor(
+          "anchor is hidden or detached; falling back to centered modal"
+        );
+      }
+      return centerLayout(viewport);
+    }
+    const rect = anchorElement.getBoundingClientRect();
+    if (!fitsBelow(rect.bottom, resolvedOffset.top, viewport.height)) {
+      return centerLayout(viewport);
+    }
+    if (!iframeFitsHorizontally(viewport.width)) {
+      return centerLayout(viewport);
+    }
+    const top = rect.bottom + resolvedOffset.top;
+    const idealLeft = placement === "bottom-end" /* BOTTOM_END */ ? rect.right - IFRAME_WIDTH + resolvedOffset.left : rect.left + resolvedOffset.left;
+    if (idealLeft < VIEWPORT_PADDING) {
+      if (warnOnInvalidAnchor) {
+        warnInvalidAnchor(
+          "anchor rect is unusable for placement; falling back to centered modal"
+        );
+      }
+      return centerLayout(viewport);
+    }
+    const left = clampHorizontal(idealLeft, viewport.width);
+    return {
+      top,
+      left,
+      width: IFRAME_WIDTH,
+      height: IFRAME_HEIGHT,
+      placement
+    };
+  }
+  function resolveIframeLayout(config, viewport = {
+    width: window.innerWidth,
+    height: window.innerHeight
+  }, options = {}) {
+    const { warnOnInvalidAnchor = true } = options;
+    const placement = resolveEffectivePlacement(config);
+    const anchorElement = resolveAnchor(config.anchor);
+    if (warnOnInvalidAnchor && placement !== "center" /* CENTER */ && !anchorElement) {
+      warnInvalidAnchor("anchor not found; falling back to centered modal");
+      return preservedAnchoredLayoutOrCenter(viewport, options);
+    }
+    if (placement === "center" /* CENTER */) {
+      return centerLayout(viewport);
+    }
+    if (!anchorElement) {
+      return preservedAnchoredLayoutOrCenter(viewport, options);
+    }
+    return computeIframeRect(
+      anchorElement,
+      placement,
+      config.offset,
+      viewport,
+      options
+    );
+  }
+  function applyOverlayBaseStyle(container) {
+    Object.assign(container.style, CONTAINER_BASE_STYLE);
+  }
+  function getVisualViewportOffset() {
+    const vv = window.visualViewport;
+    if (!vv) {
+      return { top: 0, left: 0 };
+    }
+    return { top: vv.offsetTop, left: vv.offsetLeft };
+  }
+  function getRepositionScrollTargets(anchor) {
+    const targets = /* @__PURE__ */ new Set([window]);
+    const anchorElement = resolveAnchor(anchor);
+    if (!anchorElement) {
+      return [...targets];
+    }
+    targets.add(anchorElement);
+    let parent = anchorElement.parentElement;
+    while (parent) {
+      const { overflow, overflowX, overflowY } = window.getComputedStyle(parent);
+      const overflowValue = `${overflow} ${overflowX} ${overflowY}`;
+      if (/(auto|scroll|overlay)/.test(overflowValue)) {
+        targets.add(parent);
+      }
+      parent = parent.parentElement;
+    }
+    return [...targets];
+  }
+  function applyIframeLayoutToElements(config, container, iframe, state, options = { warnOnInvalidAnchor: false }) {
+    state.layout = resolveIframeLayout(config, void 0, {
+      ...options,
+      preserveAnchoredLayout: state.lastValidAnchoredLayout
+    });
+    if (state.layout.placement !== "center" /* CENTER */) {
+      state.lastValidAnchoredLayout = state.layout;
+    }
+    const iframeStyle = {
+      ...IFRAME_STATIC_STYLE,
+      width: `${state.layout.width}px`,
+      height: `${state.layout.height}px`
+    };
+    if (state.layout.placement === "center" /* CENTER */) {
+      Object.assign(container.style, {
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        overflow: "auto"
+      });
+      Object.assign(iframe.style, iframeStyle, {
+        position: "relative",
+        top: "",
+        left: ""
+      });
+      return;
+    }
+    Object.assign(container.style, {
+      display: "block",
+      overflow: "auto"
+    });
+    const viewportOffset = getVisualViewportOffset();
+    Object.assign(iframe.style, iframeStyle, {
+      position: "fixed",
+      top: `${state.layout.top + viewportOffset.top}px`,
+      left: `${state.layout.left + viewportOffset.left}px`
+    });
+  }
+  function attachRepositionListeners(config, onReposition) {
+    const repositionHandler = onReposition;
+    const repositionScrollTargets = getRepositionScrollTargets(config.anchor);
+    repositionScrollTargets.forEach((target) => {
+      target.addEventListener("scroll", repositionHandler, { passive: true });
+    });
+    window.addEventListener("resize", repositionHandler);
+    const visualViewport = window.visualViewport;
+    visualViewport == null ? void 0 : visualViewport.addEventListener("resize", repositionHandler);
+    visualViewport == null ? void 0 : visualViewport.addEventListener("scroll", repositionHandler);
+    return {
+      remove() {
+        repositionScrollTargets.forEach((target) => {
+          target.removeEventListener("scroll", repositionHandler);
+        });
+        window.removeEventListener("resize", repositionHandler);
+        visualViewport == null ? void 0 : visualViewport.removeEventListener("resize", repositionHandler);
+        visualViewport == null ? void 0 : visualViewport.removeEventListener("scroll", repositionHandler);
+      }
+    };
+  }
+
+  // src/types/event.ts
+  var BenjiConnectEventType = /* @__PURE__ */ ((BenjiConnectEventType2) => {
+    BenjiConnectEventType2["AUTH_SUCCESS"] = "AUTH_SUCCESS";
+    BenjiConnectEventType2["FLOW_EXIT"] = "FLOW_EXIT";
+    BenjiConnectEventType2["FLOW_SUCCESS"] = "FLOW_SUCCESS";
+    BenjiConnectEventType2["EVENT"] = "EVENT";
+    BenjiConnectEventType2["ERROR"] = "ERROR";
+    return BenjiConnectEventType2;
+  })(BenjiConnectEventType || {});
+
   // src/utils/auth.ts
+  var CONNECT_MESSAGE_TYPES = new Set(Object.values(BenjiConnectEventType));
+  function isConnectMessageType(data2) {
+    if (!data2 || typeof data2 !== "object") return false;
+    const type = data2.type;
+    return typeof type === "string" && CONNECT_MESSAGE_TYPES.has(type);
+  }
   var extractAccessToken = (token) => {
     var _a;
     return typeof token === "string" ? token : (_a = token == null ? void 0 : token.access_token) != null ? _a : "";
   };
+  var extractExchangeToken = (token) => {
+    var _a;
+    return typeof token === "string" ? token : (_a = token == null ? void 0 : token.exchange_token) != null ? _a : "";
+  };
   var mapEventToConnectToken = (data2) => {
     var _a, _b, _c;
     return {
@@ -202,7 +503,7 @@ var ConnectSDK = (() => {
     };
   };
   var mapToOnSuccessData = (data2) => {
-    const token = extractAccessToken(data2.token);
+    const token = data2.action === "login" /* Login */ ? extractExchangeToken(data2.token) : extractAccessToken(data2.token);
     let metadata = {
       context: buildContext(),
       action: data2.action,
@@ -249,6 +550,9 @@ var ConnectSDK = (() => {
       this.onEvent = config.onEvent;
       this.close = config.close;
     }
+    static setMode(mode) {
+      this.mode = mode;
+    }
     static addEventListeners() {
       if (this.configuredListeners) return;
       window.addEventListener("error", this.errorEventHandler);
@@ -261,6 +565,7 @@ var ConnectSDK = (() => {
       window.removeEventListener("unhandledrejection", this.errorEventHandler);
       window.removeEventListener("message", this.messageEventHandler);
       this.configuredListeners = false;
+      this.mode = 1 /* CONNECT */;
     }
     static handleErrorMessage(event) {
       switch (event.type) {
@@ -281,8 +586,8 @@ var ConnectSDK = (() => {
       }
     }
     static handleMessage(event) {
-      var _a, _b, _c, _d, _e, _f;
-      console.debug("[Benji Connect SDK] Received message", event);
+      var _a, _b, _c, _d, _e, _f, _g;
+      if (!isConnectMessageType(event.data)) return;
       const expectedOrigin = new URL(Endpoints.benji_connect_auth_url).origin;
       if (!event || event.origin !== expectedOrigin) {
         console.warn("[Benji Connect SDK] Skipped message, received event from unexpected origin", event.origin, expectedOrigin);
@@ -312,18 +617,21 @@ var ConnectSDK = (() => {
             const connectMessage = message;
             const callbackData = BenjiConnectCallbackMapperMap.FLOW_SUCCESS(connectMessage.data);
             (_d = this.onSuccess) == null ? void 0 : _d.call(this, callbackData.token, callbackData.metadata);
+            if (this.mode === 5 /* LOGIN */) {
+              (_e = this.close) == null ? void 0 : _e.call(this);
+            }
             break;
           }
           case "ERROR" /* ERROR */: {
             const connectMessage = message;
             const callbackData = BenjiConnectCallbackMapperMap.ERROR(connectMessage.data);
-            (_e = this.onError) == null ? void 0 : _e.call(this, callbackData.error, callbackData.error_id, callbackData.metadata);
+            (_f = this.onError) == null ? void 0 : _f.call(this, callbackData.error, callbackData.error_id, callbackData.metadata);
             break;
           }
-          default: {
-            const m = message;
-            const callbackData = mapToOnEventData(m, m.data);
-            (_f = this.onEvent) == null ? void 0 : _f.call(this, callbackData.type, callbackData.metadata);
+          case "EVENT" /* EVENT */: {
+            const connectMessage = message;
+            const callbackData = mapToOnEventData(connectMessage, connectMessage.data);
+            (_g = this.onEvent) == null ? void 0 : _g.call(this, callbackData.type, callbackData.metadata);
             break;
           }
         }
@@ -332,6 +640,7 @@ var ConnectSDK = (() => {
     }
   };
   _MessageRouter.configuredListeners = false;
+  _MessageRouter.mode = 1 /* CONNECT */;
   _MessageRouter.errorEventHandler = (event) => {
     return _MessageRouter.handleErrorMessage(event);
   };
@@ -345,6 +654,17 @@ var ConnectSDK = (() => {
     constructor(config) {
       this.iframe = null;
       this.container = null;
+      this.layoutState = {
+        layout: {
+          top: 0,
+          left: 0,
+          width: IFRAME_WIDTH,
+          height: IFRAME_HEIGHT,
+          placement: "center" /* CENTER */
+        },
+        lastValidAnchoredLayout: null
+      };
+      this.repositionListeners = null;
       this.sdkConfig = config;
       if (!this.sdkConfig.environment) throw new Error("Environment is required");
       if (!this.sdkConfig.token) throw new Error("Connect token is required");
@@ -362,44 +682,48 @@ var ConnectSDK = (() => {
       });
     }
     async open() {
+      var _a;
       await this.initialize();
       this.openUI();
+      MessageRouter.setMode((_a = this.sdkConfig.mode) != null ? _a : 1 /* CONNECT */);
       MessageRouter.addEventListeners();
     }
     openUI() {
       if (this.iframe) return;
       this.container = document.createElement("div");
-      Object.assign(this.container.style, {
-        position: "fixed",
-        top: "0",
-        left: "0",
-        width: "100%",
-        height: "100%",
-        backgroundColor: "rgba(0,0,0,0.5)",
-        zIndex: "9999",
-        display: "flex",
-        alignItems: "center",
-        justifyContent: "center",
-        overflow: "auto"
-      });
+      applyOverlayBaseStyle(this.container);
       console.debug("[Connect SDK] endpoints", Endpoints);
       console.log("[Connect SDK] opeining URL", Endpoints.benji_connect_auth_url);
       const url = new URL(Endpoints.benji_connect_auth_url);
       const connectToken = this.sdkConfig.token;
       url.searchParams.set("connect_token", connectToken);
       url.searchParams.set("t", String(Date.now()));
+      if (this.sdkConfig.mode != null) {
+        url.searchParams.set("mode", String(this.sdkConfig.mode));
+      }
       this.iframe = document.createElement("iframe");
-      Object.assign(this.iframe.style, {
-        position: "relative",
-        width: "400px",
-        height: "645px",
-        border: "none",
-        borderRadius: "20px",
-        overflow: "hidden"
-      });
       this.iframe.src = url.toString();
       this.container.appendChild(this.iframe);
       document.body.appendChild(this.container);
+      applyIframeLayoutToElements(
+        this.sdkConfig,
+        this.container,
+        this.iframe,
+        this.layoutState,
+        { warnOnInvalidAnchor: true }
+      );
+      this.repositionListeners = attachRepositionListeners(
+        this.sdkConfig,
+        () => {
+          if (!this.iframe || !this.container) return;
+          applyIframeLayoutToElements(
+            this.sdkConfig,
+            this.container,
+            this.iframe,
+            this.layoutState
+          );
+        }
+      );
       this.container.addEventListener("click", (e) => {
         var _a, _b;
         if (e.target === this.container) {
@@ -412,8 +736,14 @@ var ConnectSDK = (() => {
       });
     }
     close() {
+      var _a, _b;
       if (!this.iframe) return;
-      document.body.removeChild(this.container);
+      (_a = this.repositionListeners) == null ? void 0 : _a.remove();
+      this.repositionListeners = null;
+      this.layoutState.lastValidAnchoredLayout = null;
+      if ((_b = this.container) == null ? void 0 : _b.parentNode) {
+        this.container.parentNode.removeChild(this.container);
+      }
       MessageRouter.removeEventListeners();
       this.iframe = null;
       this.container = null;