@userflow-tech/react-native 0.1.0 → 0.2.0

package/src/surfaces/tooltip/computeTooltipPosition.ts

@@ -14,13 +14,73 @@ export interface NotchPosition {
   right?: number;
 }
 
+export interface ViewportInsets {
+  top: number;
+  right: number;
+  bottom: number;
+  left: number;
+}
+
 export interface TooltipLayout {
   cardPosition: Position;
   notchPosition: NotchPosition;
+  /**
+   * False when the clamped card is no longer adjacent to the target, or the
+   * target's centre on the cross axis has left the card's span. Callers should
+   * hide the pointer rather than aim it at empty space.
+   */
+  showNotch: boolean;
   /** Padded target rect used for the cutout hole. */
   targetHighlightRect: { top: number; left: number; width: number; height: number };
 }
 
+/** Pixel slack so a card that sits exactly on the target edge still counts. */
+const ADJACENCY_EPSILON = 0.5;
+
+function notchCanPointAtTarget(opts: {
+  placement: TooltipPlacementSide;
+  cx: number;
+  cy: number;
+  bw: number;
+  bh: number;
+  targetRect: { top: number; right: number; bottom: number; left: number };
+  notchSize: number;
+}): boolean {
+  if (opts.notchSize <= 0) return false;
+  const { placement, cx, cy, bw, bh, targetRect } = opts;
+  const targetMidX = targetRect.left + (targetRect.right - targetRect.left) / 2;
+  const targetMidY = targetRect.top + (targetRect.bottom - targetRect.top) / 2;
+  const reachableX =
+    targetMidX >= cx - ADJACENCY_EPSILON && targetMidX <= cx + bw + ADJACENCY_EPSILON;
+  const reachableY =
+    targetMidY >= cy - ADJACENCY_EPSILON && targetMidY <= cy + bh + ADJACENCY_EPSILON;
+
+  switch (placement) {
+    case 'BELOW':
+      return cy + ADJACENCY_EPSILON >= targetRect.bottom && reachableX;
+    case 'ABOVE':
+      return cy + bh <= targetRect.top + ADJACENCY_EPSILON && reachableX;
+    case 'RIGHT':
+      return cx + ADJACENCY_EPSILON >= targetRect.right && reachableY;
+    case 'LEFT':
+      return cx + bw <= targetRect.left + ADJACENCY_EPSILON && reachableY;
+    default:
+      return false;
+  }
+}
+
+function resolveViewportInsets(
+  viewportPadding: number,
+  viewportInsets?: Partial<ViewportInsets>,
+): ViewportInsets {
+  return {
+    top: viewportInsets?.top ?? viewportPadding,
+    right: viewportInsets?.right ?? viewportPadding,
+    bottom: viewportInsets?.bottom ?? viewportPadding,
+    left: viewportInsets?.left ?? viewportPadding,
+  };
+}
+
 /**
  * Side length of the axis-aligned square that, when rotated 45°, yields a
  * tip that protrudes `notchSize` beyond the card edge (half-diagonal = N).
@@ -43,10 +103,21 @@ export function computeTooltipPosition(opts: {
   placement: TooltipPlacementSide;
   notchSize: number;
   backdropPadding?: number;
+  /**
+   * Extra placement inset when the highlight ring is outside the hole
+   * (`backdropHighlightType: OUTSIDE`). Includes theme spread plus the painted
+   * stroke and halo so the notch aims at the ring's outer edge.
+   */
+  outsideHighlightSpread?: number;
   windowSize: WindowSize;
   bubbleBorderRadius: number;
   bubbleBorderWidth?: number;
   viewportPadding?: number;
+  /**
+   * Per-edge screen margin. When omitted, {@link viewportPadding} is used on
+   * every side so ABOVE/BELOW keep the same 24px gap as LEFT/RIGHT.
+   */
+  viewportInsets?: Partial<ViewportInsets>;
 }): TooltipLayout {
   const {
     target,
@@ -54,21 +125,25 @@ export function computeTooltipPosition(opts: {
     placement,
     notchSize,
     backdropPadding = 0,
+    outsideHighlightSpread = 0,
     windowSize,
     bubbleBorderRadius,
     bubbleBorderWidth = 0,
     viewportPadding = VIEWPORT_PADDING,
+    viewportInsets,
   } = opts;
   const { width: cw, height: ch } = windowSize;
   const { width: bw, height: bh } = bubbleSize;
+  const pad = resolveViewportInsets(viewportPadding, viewportInsets);
 
+  const placementPad = backdropPadding + outsideHighlightSpread;
   const targetRect = {
-    top: target.y - backdropPadding,
-    right: target.x + target.width + backdropPadding,
-    bottom: target.y + target.height + backdropPadding,
-    left: target.x - backdropPadding,
-    width: target.width + backdropPadding * 2,
-    height: target.height + backdropPadding * 2,
+    top: target.y - placementPad,
+    right: target.x + target.width + placementPad,
+    bottom: target.y + target.height + placementPad,
+    left: target.x - placementPad,
+    width: target.width + placementPad * 2,
+    height: target.height + placementPad * 2,
   };
 
   let cx = 0;
@@ -80,34 +155,36 @@ export function computeTooltipPosition(opts: {
 
   if (placement === 'BELOW' || placement === 'ABOVE') {
     cx = targetRect.left + targetRect.width / 2 - bw / 2;
-    cx = Math.max(viewportPadding, Math.min(cw - bw - viewportPadding, cx));
+    cx = Math.max(pad.left, Math.min(cw - bw - pad.right, cx));
 
     const rawLeft = targetRect.left + targetRect.width / 2 - half - cx;
     notch.left = Math.max(bubbleBorderRadius, Math.min(bw - bubbleBorderRadius - side, rawLeft));
 
     if (placement === 'BELOW') {
       cy = targetRect.bottom + notchSize;
-      cy = Math.max(notchSize, Math.min(ch - bh, cy));
+      cy = Math.max(pad.top, Math.min(ch - bh - pad.bottom, cy));
       notch.top = edgeOffset;
     } else {
       cy = targetRect.top - notchSize - bh;
-      cy = Math.max(0, Math.min(ch - bh - notchSize, cy));
+      cy = Math.max(pad.top, Math.min(ch - bh - pad.bottom, cy));
       notch.bottom = edgeOffset;
     }
   } else {
     cy = targetRect.top + targetRect.height / 2 - bh / 2;
-    cy = Math.max(viewportPadding, Math.min(ch - bh - viewportPadding, cy));
+    cy = Math.max(pad.top, Math.min(ch - bh - pad.bottom, cy));
 
     const rawTop = targetRect.top + targetRect.height / 2 - half - cy;
     notch.top = Math.max(bubbleBorderRadius, Math.min(bh - bubbleBorderRadius - side, rawTop));
 
+    // LEFT keeps pad.left; RIGHT used to min at notchSize, which sat inside the
+    // screen margin when the target was near the left edge.
     if (placement === 'RIGHT') {
       cx = targetRect.right + notchSize;
-      cx = Math.max(notchSize, Math.min(cw - bw, cx));
+      cx = Math.max(pad.left, Math.min(cw - bw - pad.right, cx));
       notch.left = edgeOffset;
     } else {
       cx = targetRect.left - notchSize - bw;
-      cx = Math.max(0, Math.min(cw - bw - notchSize, cx));
+      cx = Math.max(pad.left, Math.min(cw - bw - notchSize, cx));
       notch.right = edgeOffset;
     }
   }
@@ -115,6 +192,15 @@ export function computeTooltipPosition(opts: {
   return {
     cardPosition: { x: cx, y: cy },
     notchPosition: notch,
+    showNotch: notchCanPointAtTarget({
+      placement,
+      cx,
+      cy,
+      bw,
+      bh,
+      targetRect,
+      notchSize,
+    }),
     targetHighlightRect: {
       top: target.y - backdropPadding,
       left: target.x - backdropPadding,

package/src/surfaces/tooltip/inferTooltipPlacement.ts

@@ -27,9 +27,95 @@ import { TOOLTIP_VIEWPORT_PADDING } from '../resolveTooltipLayout';
 
 export const VIEWPORT_PADDING = TOOLTIP_VIEWPORT_PADDING;
 
+/** Per-edge screen margin; each omitted edge falls back to `viewportPadding`. */
+export interface TooltipViewportInsets {
+  top?: number;
+  right?: number;
+  bottom?: number;
+  left?: number;
+}
+
+export interface TooltipPlacementFitsOpts {
+  target: Rect;
+  bubbleSize: Size;
+  notchSize: number;
+  windowSize: WindowSize;
+  placement: TooltipPlacementSide;
+  viewportPadding?: number;
+  /**
+   * Per-edge screen margin. When omitted, `viewportPadding` is used on every
+   * side so this agrees with `computeTooltipPosition`'s clamp.
+   */
+  viewportInsets?: TooltipViewportInsets;
+  /**
+   * When set, ABOVE/BELOW compare against `min(height, minHeight)` so a
+   * scrollable card that can shrink is allowed to fit. Omit to keep the
+   * historical full-height check used by {@link inferTooltipPlacement}.
+   */
+  minHeight?: number;
+}
+
+/**
+ * Whether `placement` has room beside `target` for `bubbleSize`.
+ *
+ * Inclusive: a card that exactly fills the remaining gap (LEFT/RIGHT after
+ * side-narrowing) still fits. Every side reserves the matching edge margin so
+ * this agrees with the clamp in `computeTooltipPosition`; when the two
+ * disagree, a placement passes here and is then drawn somewhere else.
+ */
+export function tooltipPlacementFits({
+  target,
+  bubbleSize,
+  notchSize,
+  windowSize,
+  placement,
+  viewportPadding = VIEWPORT_PADDING,
+  viewportInsets,
+  minHeight,
+}: TooltipPlacementFitsOpts): boolean {
+  const { width: cw, height: ch } = windowSize;
+  const { width: bw, height: bh } = bubbleSize;
+  const clip = { top: 0, right: cw, bottom: ch, left: 0 };
+  const targetRect = {
+    top: target.y,
+    right: target.x + target.width,
+    bottom: target.y + target.height,
+    left: target.x,
+    width: target.width,
+    height: target.height,
+  };
+  const midX = targetRect.left + targetRect.width / 2;
+  const midY = targetRect.top + targetRect.height / 2;
+  const midXIn = midX >= clip.left && midX <= clip.right;
+  const midYIn = midY >= clip.top && midY <= clip.bottom;
+  const verticalHeight =
+    minHeight != null && Number.isFinite(minHeight) ? Math.min(bh, Math.max(0, minHeight)) : bh;
+  const padTop = viewportInsets?.top ?? viewportPadding;
+  const padRight = viewportInsets?.right ?? viewportPadding;
+  const padBottom = viewportInsets?.bottom ?? viewportPadding;
+  const padLeft = viewportInsets?.left ?? viewportPadding;
+
+  switch (placement) {
+    case 'BELOW':
+      return ch - targetRect.bottom >= verticalHeight + notchSize + padBottom && midXIn;
+    case 'ABOVE':
+      return targetRect.top >= verticalHeight + notchSize + padTop && midXIn;
+    case 'RIGHT':
+      return cw - targetRect.right >= bw + notchSize + padRight && midYIn;
+    case 'LEFT':
+      return targetRect.left >= bw + notchSize + padLeft && midYIn;
+    default:
+      return false;
+  }
+}
+
 /**
  * Port of web FlowChrome `inferTooltipPlacement` with distance-sorted flip
  * (not the prototype's fixed BELOW→ABOVE→RIGHT→LEFT priority).
+ *
+ * When no side fits, returns `desiredPlacement` (or BELOW) as a last resort —
+ * callers must check {@link tooltipPlacementFits} on the result to tell a real
+ * fit from that fallback.
  */
 export function inferTooltipPlacement({
   target,
@@ -38,6 +124,9 @@ export function inferTooltipPlacement({
   windowSize,
   currentPlacement,
   desiredPlacement,
+  viewportPadding = VIEWPORT_PADDING,
+  viewportInsets,
+  minHeight,
 }: {
   target: Rect;
   bubbleSize: Size;
@@ -45,6 +134,13 @@ export function inferTooltipPlacement({
   windowSize: WindowSize;
   currentPlacement: TooltipPlacementSide | null;
   desiredPlacement: TooltipPlacementSide | null;
+  viewportPadding?: number;
+  /**
+   * Per-edge screen margin. When omitted, `viewportPadding` is used on every
+   * side so infer agrees with `computeTooltipPosition`'s clamp.
+   */
+  viewportInsets?: TooltipViewportInsets;
+  minHeight?: number;
 }): TooltipPlacementSide {
   const { width: cw, height: ch } = windowSize;
   const { width: bw, height: bh } = bubbleSize;
@@ -72,24 +168,17 @@ export function inferTooltipPlacement({
     return clip.right > bw + notchSize ? 'LEFT' : 'RIGHT';
   }
 
-  const fits = (p: TooltipPlacementSide): boolean => {
-    const midX = targetRect.left + targetRect.width / 2;
-    const midY = targetRect.top + targetRect.height / 2;
-    const midXIn = midX >= clip.left && midX <= clip.right;
-    const midYIn = midY >= clip.top && midY <= clip.bottom;
-    switch (p) {
-      case 'BELOW':
-        return ch - targetRect.bottom > bh + notchSize && midXIn;
-      case 'ABOVE':
-        return targetRect.top > bh + notchSize && midXIn;
-      case 'RIGHT':
-        return cw - targetRect.right > bw + notchSize && midYIn;
-      case 'LEFT':
-        return targetRect.left > bw + notchSize && midYIn;
-      default:
-        return false;
-    }
-  };
+  const fits = (p: TooltipPlacementSide): boolean =>
+    tooltipPlacementFits({
+      target,
+      bubbleSize,
+      notchSize,
+      windowSize,
+      placement: p,
+      viewportPadding,
+      ...(viewportInsets != null ? { viewportInsets } : {}),
+      ...(minHeight != null ? { minHeight } : {}),
+    });
 
   if (desiredPlacement && fits(desiredPlacement)) return desiredPlacement;
   if (currentPlacement && fits(currentPlacement)) return currentPlacement;

package/src/surfaces/tooltip/placementDiagnostics.ts

@@ -0,0 +1,70 @@
+import type { TooltipPlacementSide } from './inferTooltipPlacement';
+
+const PREFIX = '[Userflow]';
+
+/** Sink for placement diagnostics. Injected in tests. */
+export type PlacementLogger = (message: string) => void;
+
+export const defaultPlacementLogger: PlacementLogger = (message) => {
+  // eslint-disable-next-line no-console -- intentional development diagnostic
+  console.warn(message);
+};
+
+/**
+ * A Builder-requested LEFT/RIGHT side could not be drawn at all: the room
+ * beside the target is smaller than the card's own chrome, so no width is left
+ * to lay content out in. Draft/preview and `__DEV__` only.
+ *
+ * The caller must not emit this when the side was honored at a reduced width —
+ * shrinking is the expected outcome now, and whether it looks good is the
+ * author's call — nor for keyboard / off-screen vertical flips, whose cause is
+ * not the room beside the target.
+ */
+export function tooltipSidePlacementDroppedMessage(opts: {
+  requested: 'LEFT' | 'RIGHT';
+  used: TooltipPlacementSide;
+  availableGap: number;
+  minWidth: number;
+}): string {
+  const gap = Number.isFinite(opts.availableGap) ? Math.max(0, Math.floor(opts.availableGap)) : 0;
+  const minWidth = Number.isFinite(opts.minWidth) ? Math.max(0, Math.ceil(opts.minWidth)) : 0;
+  return (
+    `${PREFIX} Tooltip placement "${opts.requested}" could not be drawn beside the target ` +
+    `(${gap}pt of room beside it; the card needs ${minWidth}pt for its padding and border). ` +
+    `Placed ${opts.used} instead.`
+  );
+}
+
+export function warnTooltipSidePlacementDropped(
+  opts: {
+    requested: 'LEFT' | 'RIGHT';
+    used: TooltipPlacementSide;
+    availableGap: number;
+    minWidth: number;
+  },
+  log: PlacementLogger = defaultPlacementLogger,
+): void {
+  log(tooltipSidePlacementDroppedMessage(opts));
+}
+
+/**
+ * No side had room for the card — including the authored LEFT/RIGHT — so
+ * {@link inferTooltipPlacement} returned the requested side as a last resort.
+ * Draft/preview and `__DEV__` only. Distinct from
+ * {@link tooltipSidePlacementDroppedMessage}, which reports a successful flip.
+ */
+export function tooltipPlacementUnanchoredMessage(opts: {
+  requested: TooltipPlacementSide;
+}): string {
+  return (
+    `${PREFIX} Tooltip placement "${opts.requested}" could not be drawn on any side of the target. ` +
+    `The card is on-screen but the pointer is hidden because it cannot point at the target.`
+  );
+}
+
+export function warnTooltipPlacementUnanchored(
+  opts: { requested: TooltipPlacementSide },
+  log: PlacementLogger = defaultPlacementLogger,
+): void {
+  log(tooltipPlacementUnanchoredMessage(opts));
+}

package/src/surfaces/tooltip/rect.ts

@@ -1,5 +1,16 @@
 import type { Rect, WindowSize } from './inferTooltipPlacement';
 
+/** Grow or shrink `rect` by `padding` on every side. */
+export function expandRect(rect: Rect, padding: number): Rect {
+  if (padding === 0) return rect;
+  return {
+    x: rect.x - padding,
+    y: rect.y - padding,
+    width: rect.width + padding * 2,
+    height: rect.height + padding * 2,
+  };
+}
+
 /** True when two rects are identical (used to avoid redundant setState). */
 export function rectsEqual(a: Rect | null, b: Rect | null): boolean {
   if (a === b) return true;

package/src/surfaces/tooltip/resolveSideCardWidth.ts

@@ -0,0 +1,121 @@
+import type { Rect } from './inferTooltipPlacement';
+import { VIEWPORT_PADDING } from './inferTooltipPlacement';
+
+/**
+ * Narrowest a side card may get: the width it spends on its own chrome, so
+ * content padding on both edges plus the border. Below this there is nothing
+ * left to lay text out in, and React Native overflows the card instead of
+ * shrinking it — the preview would stop showing the author what ships.
+ *
+ * Deliberately structural, not a readability judgment. How narrow is *too*
+ * narrow to read is the author's call, made against the device preview.
+ */
+export function tooltipMinSideCardWidth(opts: {
+  contentPadding: number;
+  borderWidth?: number;
+  cardMaxWidth: number;
+}): number {
+  const contentPadding = Number.isFinite(opts.contentPadding)
+    ? Math.max(0, opts.contentPadding)
+    : 0;
+  const borderWidth =
+    opts.borderWidth != null && Number.isFinite(opts.borderWidth)
+      ? Math.max(0, opts.borderWidth)
+      : 0;
+  const chromeWidth = contentPadding * 2 + borderWidth * 2;
+  // Never demand more width than the card itself: a 40pt step card can still
+  // sit on the side even though its own padding would ask for more.
+  if (!Number.isFinite(opts.cardMaxWidth) || opts.cardMaxWidth <= 0) return chromeWidth;
+  return Math.min(chromeWidth, opts.cardMaxWidth);
+}
+
+/**
+ * Horizontal room beside an expanded target for a LEFT/RIGHT tooltip.
+ *
+ * Reserves `viewportPadding` on the screen edge the card grows toward, matching
+ * the LEFT/RIGHT clamp in `computeTooltipPosition`. Web clamps side placements
+ * to the raw edge instead; RN keeps the screen margin because an edge-to-edge
+ * card reads as broken on a phone-width viewport.
+ */
+export function tooltipSideGap(opts: {
+  placement: 'LEFT' | 'RIGHT';
+  target: Rect;
+  windowWidth: number;
+  notchSize: number;
+  viewportPadding?: number;
+}): number {
+  const { placement, target, windowWidth, notchSize, viewportPadding = VIEWPORT_PADDING } = opts;
+  if (placement === 'LEFT') {
+    return target.x - notchSize - viewportPadding;
+  }
+  return windowWidth - (target.x + target.width) - notchSize - viewportPadding;
+}
+
+/**
+ * Width a LEFT/RIGHT tooltip may use: the room beside the target, capped at the
+ * theme width. The card takes whatever is left and grows taller to compensate.
+ * Null when not even {@link tooltipMinSideCardWidth} fits, so placement falls
+ * back to the vertical flip.
+ *
+ * `target` must already be expanded by backdrop padding and outside highlight
+ * spread — the same rect passed to `inferTooltipPlacement`.
+ */
+export function resolveTooltipSideCardWidth(opts: {
+  placement: 'LEFT' | 'RIGHT';
+  target: Rect;
+  windowWidth: number;
+  notchSize: number;
+  cardMaxWidth: number;
+  minWidth: number;
+  viewportPadding?: number;
+}): number | null {
+  const gap = tooltipSideGap(opts);
+  const width = Math.min(opts.cardMaxWidth, Math.floor(gap));
+  if (!Number.isFinite(width) || width <= 0 || width < opts.minWidth) return null;
+  return width;
+}
+
+/**
+ * Shortest a card may get: the height it spends on its own chrome, so
+ * content padding on both edges plus the border. Mirrors
+ * {@link tooltipMinSideCardWidth} on the vertical axis.
+ */
+export function tooltipMinCardHeight(opts: {
+  contentPadding: number;
+  borderWidth?: number;
+  cardMaxHeight: number;
+}): number {
+  const contentPadding = Number.isFinite(opts.contentPadding)
+    ? Math.max(0, opts.contentPadding)
+    : 0;
+  const borderWidth =
+    opts.borderWidth != null && Number.isFinite(opts.borderWidth)
+      ? Math.max(0, opts.borderWidth)
+      : 0;
+  const chromeHeight = contentPadding * 2 + borderWidth * 2;
+  if (!Number.isFinite(opts.cardMaxHeight) || opts.cardMaxHeight <= 0) return chromeHeight;
+  return Math.min(chromeHeight, opts.cardMaxHeight);
+}
+
+/**
+ * Vertical room above or below an expanded target for an ABOVE/BELOW tooltip.
+ *
+ * Reserves the matching viewport inset on the edge the card grows toward,
+ * matching the ABOVE/BELOW clamp in `computeTooltipPosition`.
+ */
+export function tooltipVerticalGap(opts: {
+  placement: 'ABOVE' | 'BELOW';
+  target: Rect;
+  windowHeight: number;
+  notchSize: number;
+  viewportPadding?: number;
+  viewportInsets?: { top?: number; bottom?: number };
+}): number {
+  const { placement, target, windowHeight, notchSize, viewportPadding = VIEWPORT_PADDING } = opts;
+  const top = opts.viewportInsets?.top ?? viewportPadding;
+  const bottom = opts.viewportInsets?.bottom ?? viewportPadding;
+  if (placement === 'ABOVE') {
+    return target.y - notchSize - top;
+  }
+  return windowHeight - (target.y + target.height) - notchSize - bottom;
+}

package/src/version.ts

@@ -1,2 +1,2 @@
 /** Generated by scripts/write-version.mjs — do not edit. */
-export const SDK_VERSION = '0.1.0';
+export const SDK_VERSION = '0.2.0';

package/vendor/core/LICENSE

@@ -0,0 +1,76 @@
+Userflow React Native SDK
+
+Copyright (c) 2026 Userflow Inc. All rights reserved.
+
+PROPRIETARY AND CONFIDENTIAL
+
+This software and its source code (the "Software") are the proprietary and
+confidential property of Userflow Inc. ("Userflow"). The Software is licensed,
+not sold.
+
+1. Grant of License
+
+   Use of the Software is permitted only by parties who have entered into a
+   written agreement with Userflow that expressly covers the Software (the
+   "Agreement"), and only for the duration, purposes, and scope set out in
+   that Agreement. Where the Software is provided for evaluation or as part
+   of an early-access or design-partner program, use is limited to internal
+   evaluation and integration testing unless the Agreement states otherwise.
+
+   If you have not entered into such an Agreement with Userflow, you are
+   granted no rights to use, copy, modify, or distribute the Software.
+
+2. Restrictions
+
+   Except as expressly permitted by the Agreement or by applicable law, you
+   may not:
+
+   (a) redistribute, sublicense, sell, rent, lease, or otherwise transfer the
+       Software or any portion of it to any third party, except that you may
+       ship the Software in compiled or bundled form as an integral part of
+       your own applications distributed to your end users, provided you do
+       not redistribute the Software as a standalone library or SDK;
+   (b) modify or create derivative works of the Software, except for
+       automated transformations performed by ordinary build tooling
+       (including transpilation, bundling, minification, tree-shaking, and
+       source-map generation) and other modifications reasonably necessary
+       to integrate the Software into your applications, provided that any
+       such modifications remain subject to this notice;
+   (c) remove or obscure any copyright, trademark, or other proprietary
+       notices contained in the Software;
+   (d) disclose the Software's source code to any third party, except to your
+       employees and contractors who need access for a purpose permitted by
+       the Agreement and who are bound by written confidentiality
+       obligations no less protective than those in the Agreement.
+
+3. Pre-Release Software
+
+   The Software may be provided prior to general availability. It may be
+   incomplete, may change without notice, and may not be backward compatible
+   between versions. Userflow is under no obligation to provide maintenance,
+   support, updates, or future releases except as set out in the Agreement.
+
+4. No Warranty
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT.
+
+5. Limitation of Liability
+
+   TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, IN NO EVENT SHALL
+   USERFLOW BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER IN
+   AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM, OUT OF, OR IN
+   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+6. Precedence
+
+   In the event of a conflict between this notice and the Agreement, the
+   Agreement governs.
+
+For licensing enquiries, contact:
+
+Userflow Inc.
+548 Market St PMB 69598
+San Francisco, CA 94104-5401
+United States

package/vendor/core/README.md

@@ -0,0 +1,9 @@
+# `@userflow-tech/core`
+
+Platform-agnostic engine for the Userflow React Native SDK (transport, identity,
+flow session, client conditions).
+
+**This package is an implementation detail and is not published.** It is
+vendored into `@userflow-tech/react-native` at pack time. Host apps should
+depend on that package only. Do not import `@userflow-tech/core` from
+application code.

package/vendor/core/dist/attributes.d.ts

@@ -0,0 +1,15 @@
+/** Attribute scope used when validating names. Matches backend scopes. */
+export type AttributeScope = 'user' | 'group' | 'group_membership' | 'event';
+/** Keep in sync with `Flows.validate_attribute_name` / `validateAttributeDefinitionName`. */
+export declare const MAX_ATTRIBUTE_NAME_LENGTH = 100;
+/** Keep in sync with `Flows.validate_event_name` max length. */
+export declare const MAX_EVENT_NAME_LENGTH = 255;
+/** Returns true when `name` only contains supported attribute name characters. */
+export declare function isAttributeNameSoftValid(name: string): boolean;
+/** Returns an error message when invalid, or `null` when the name is allowed. */
+export declare function validateAttributeName(scope: AttributeScope, name: string): string | null;
+/** Throws when any attribute name is invalid for the given scope. */
+export declare function assertValidAttributeNames(scope: AttributeScope, attributes: Record<string, unknown>): void;
+/** Throws when the custom event name is invalid. */
+export declare function assertValidEventName(name: string): void;
+//# sourceMappingURL=attributes.d.ts.map

package/vendor/core/dist/attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../src/attributes.ts"],"names":[],"mappings":"AAEA,0EAA0E;AAC1E,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,OAAO,GAAG,kBAAkB,GAAG,OAAO,CAAC;AAE7E,6FAA6F;AAC7F,eAAO,MAAM,yBAAyB,MAAM,CAAC;AAE7C,gEAAgE;AAChE,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAczC,kFAAkF;AAClF,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED,iFAAiF;AACjF,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAcxF;AAED,qEAAqE;AACrE,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,cAAc,EACrB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAClC,IAAI,CAQN;AAED,oDAAoD;AACpD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAcvD"}