@userflow-tech/react-native 0.1.0

package/lib/typescript/module/src/anchors/fiber/FiberScanRoot.d.ts

@@ -0,0 +1,41 @@
+import * as React from 'react';
+import { type AnyFiber } from './fiberInternals';
+type Listener = () => void;
+/**
+ * Module singleton holding the fiber under which testID / nativeID /
+ * accessibilityLabel scans run. Seeded by {@link FiberScanRoot}.
+ */
+declare class FiberScanRootStore {
+    private instance;
+    private readonly listeners;
+    set(instance: unknown): void;
+    clear(): void;
+    /** Current (resolved) fiber under the scan root, or null when unmounted. */
+    getFiber(): AnyFiber | null;
+    subscribe(listener: Listener): () => void;
+    /** Test helper. */
+    resetForTests(): void;
+    private emit;
+}
+export declare const fiberScanRoot: FiberScanRootStore;
+export interface FiberScanRootProps {
+    children: React.ReactNode;
+}
+/**
+ * Class component that publishes its own `_reactInternals` fiber as the scan
+ * root for testID-based anchoring. Class instances expose `_reactInternals` in
+ * both Paper and Fabric production builds (unlike host refs, which null out
+ * `_internalFiberInstanceHandleDEV` on Paper release).
+ *
+ * Renders the same content-root `View` that {@link UserflowProvider} previously
+ * owned so the layout tree is unchanged. The Userflow overlay sits as a
+ * *sibling*, so SDK-owned `testID`s never self-match.
+ */
+export declare class FiberScanRoot extends React.Component<FiberScanRootProps> {
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    componentWillUnmount(): void;
+    render(): React.ReactElement;
+}
+export {};
+//# sourceMappingURL=FiberScanRoot.d.ts.map

package/lib/typescript/module/src/anchors/fiber/FiberScanRoot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FiberScanRoot.d.ts","sourceRoot":"","sources":["../../../../../../src/anchors/fiber/FiberScanRoot.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,OAAO,EAAE,KAAK,QAAQ,EAAgD,MAAM,kBAAkB,CAAC;AAE/F,KAAK,QAAQ,GAAG,MAAM,IAAI,CAAC;AAE3B;;;GAGG;AACH,cAAM,kBAAkB;IACtB,OAAO,CAAC,QAAQ,CAAiB;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAuB;IAEjD,GAAG,CAAC,QAAQ,EAAE,OAAO,GAAG,IAAI;IAK5B,KAAK,IAAI,IAAI;IAKb,4EAA4E;IAC5E,QAAQ,IAAI,QAAQ,GAAG,IAAI;IAO3B,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,IAAI;IAOzC,mBAAmB;IACnB,aAAa,IAAI,IAAI;IAKrB,OAAO,CAAC,IAAI;CAKb;AAED,eAAO,MAAM,aAAa,oBAA2B,CAAC;AAEtD,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAED;;;;;;;;;GASG;AACH,qBAAa,aAAc,SAAQ,KAAK,CAAC,SAAS,CAAC,kBAAkB,CAAC;IAC3D,iBAAiB,IAAI,IAAI;IAIzB,kBAAkB,IAAI,IAAI;IAM1B,oBAAoB,IAAI,IAAI;IAI5B,MAAM,IAAI,KAAK,CAAC,YAAY;CAOtC"}

package/lib/typescript/module/src/anchors/fiber/fiberInternals.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Compatibility layer for the React Native / React **internals** that
+ * testID-based anchoring depends on. Every accessor is feature-detected and
+ * **never throws** (returns `undefined`/`false`/`null` on a missing or renamed
+ * field) so an RN shape change degrades to not-found rather than crashing the
+ * host app.
+ *
+ * Explicitly **no** `__REACT_DEVTOOLS_GLOBAL_HOOK__`. Fibers are reached only
+ * through production-present pointers on class instances (`_reactInternals`).
+ */
+export type AnyFiber = any;
+/**
+ * Bound for `return`-pointer walks. Only a loop guard, not a real limit:
+ * measured fiber depth in a modest Expo Router app is already ~150 from a
+ * tagged view to the provider, and ~80 from the provider to the HostRoot, so a
+ * small cap silently disables the walk instead of protecting anything.
+ */
+export declare const MAX_ANCESTOR_WALK = 10000;
+export declare function getChild(fiber: AnyFiber): AnyFiber | null;
+export declare function getSibling(fiber: AnyFiber): AnyFiber | null;
+export declare function getReturn(fiber: AnyFiber): AnyFiber | null;
+export declare function getAlternate(fiber: AnyFiber): AnyFiber | null;
+export declare function getMemoizedProps(fiber: AnyFiber): Record<string, unknown> | undefined;
+export declare function getStateNode(fiber: AnyFiber): unknown;
+export declare function getFiberTag(fiber: AnyFiber): number | undefined;
+/** Native component name for a host fiber (e.g. `RNSScreen`), else undefined. */
+export declare function getHostTypeName(fiber: AnyFiber): string | undefined;
+/**
+ * True when `fiber` is a host component. Checks both Paper/Fabric stateNode
+ * markers and the HostComponent tag (react-test-renderer host fibers often
+ * have `tag === 5` without native keys).
+ */
+export declare function isHostFiber(fiber: AnyFiber): boolean;
+/** Resolve a fiber from a class or host public instance. Returns null when unavailable. */
+export declare function fiberFromPublicInstance(instance: unknown): AnyFiber | null;
+/**
+ * Pick the "current" tree fiber between `fiber` and its alternate by walking
+ * to the HostRoot and comparing against `root.stateNode.current`.
+ *
+ * Returns the input fiber when the root cannot be resolved (best-effort).
+ */
+export declare function resolveCurrentFiber(fiber: AnyFiber): AnyFiber;
+/**
+ * True when a previously-resolved fiber is still attached to a live tree
+ * (has a return path, or is itself a HostRoot).
+ */
+export declare function isFiberMounted(fiber: AnyFiber): boolean;
+//# sourceMappingURL=fiberInternals.d.ts.map

package/lib/typescript/module/src/anchors/fiber/fiberInternals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fiberInternals.d.ts","sourceRoot":"","sources":["../../../../../../src/anchors/fiber/fiberInternals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,MAAM,MAAM,QAAQ,GAAG,GAAG,CAAC;AAQ3B;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,QAAS,CAAC;AAaxC,wBAAgB,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,QAAQ,GAAG,IAAI,CAEzD;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,QAAQ,GAAG,QAAQ,GAAG,IAAI,CAE3D;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,QAAQ,GAAG,QAAQ,GAAG,IAAI,CAE1D;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,GAAG,QAAQ,GAAG,IAAI,CAE7D;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAGrF;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAErD;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,GAAG,SAAS,CAG/D;AAED,iFAAiF;AACjF,wBAAgB,eAAe,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,GAAG,SAAS,CAGnE;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAiBpD;AAaD,2FAA2F;AAC3F,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,OAAO,GAAG,QAAQ,GAAG,IAAI,CAa1E;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,QAAQ,GAAG,QAAQ,CAuB7D;AAWD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CASvD"}

package/lib/typescript/module/src/anchors/fiber/findAnchorFiber.d.ts

@@ -0,0 +1,33 @@
+import { type AnyFiber } from './fiberInternals';
+export type AnchorPropTier = 'testID' | 'nativeID' | 'accessibilityLabel';
+export type FindAnchorFiberResult = {
+    status: 'found';
+    fiber: AnyFiber;
+    tier: AnchorPropTier;
+} | {
+    status: 'ambiguous';
+    tier: AnchorPropTier;
+} | {
+    status: 'missing';
+};
+/**
+ * Bounded DFS under `rootFiber` looking for fibers whose memoizedProps match
+ * `id` on testID, then nativeID, then accessibilityLabel. Uses the highest
+ * tier that has any match so a testID hit is never made ambiguous by an
+ * unrelated accessibilityLabel.
+ *
+ * Composite matches descend to the shallowest host descendant. Multiple
+ * matches on a single root-to-leaf chain (e.g. Pressable forwarding testID to
+ * its inner View) collapse to the outermost host. Disjoint matches fail closed
+ * as ambiguous.
+ *
+ * The walk never follows `rootFiber.sibling` so the Userflow overlay (a sibling
+ * of {@link FiberScanRoot} in UserflowProvider) cannot self-match SDK testIDs.
+ */
+export declare function findAnchorFiber(rootFiber: AnyFiber, id: string): FindAnchorFiberResult;
+/**
+ * BFS under `fiber` for the shallowest host descendant. Returns `fiber` itself
+ * when it is already a host.
+ */
+export declare function nearestHostDescendant(fiber: AnyFiber, maxNodes?: number): AnyFiber | null;
+//# sourceMappingURL=findAnchorFiber.d.ts.map

package/lib/typescript/module/src/anchors/fiber/findAnchorFiber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findAnchorFiber.d.ts","sourceRoot":"","sources":["../../../../../../src/anchors/fiber/findAnchorFiber.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,QAAQ,EAOd,MAAM,kBAAkB,CAAC;AAa1B,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,UAAU,GAAG,oBAAoB,CAAC;AAI1E,MAAM,MAAM,qBAAqB,GAC7B;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,cAAc,CAAA;CAAE,GAC1D;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,cAAc,CAAA;CAAE,GAC7C;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,CAAC;AAE1B;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,GAAG,qBAAqB,CAkGtF;AAsBD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,QAAQ,EAAE,QAAQ,SAAQ,GAAG,QAAQ,GAAG,IAAI,CAkBxF"}

package/lib/typescript/module/src/anchors/fiber/findScrollAncestors.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Walk the fiber `return` chain from an anchor host upward and collect
+ * scrollable ancestors (innermost first). Used to scroll tooltip targets into
+ * view without requiring the host app to register ScrollViews.
+ *
+ * Detection is duck-typed on `stateNode` (ScrollView → `scrollTo`,
+ * FlatList/VirtualizedList → `scrollToOffset`, SectionList → `scrollToLocation`)
+ * so an RN rename degrades to "no scroll ancestor" rather than crashing.
+ */
+import { type AnyFiber } from './fiberInternals';
+export interface ScrollAncestor {
+    /** Class / composite instance that exposes scrollTo / scrollToOffset / … */
+    instance: ScrollableInstance;
+    /** Host fiber for the scroll viewport (RCTScrollView), when resolvable. */
+    containerFiber: AnyFiber | null;
+    /** Host fiber for the content view that translates with scroll, when resolvable. */
+    contentFiber: AnyFiber | null;
+    /** True when the scroller scrolls on the horizontal axis. */
+    horizontal: boolean;
+}
+export type ScrollableInstance = {
+    scrollTo?: (options: {
+        x?: number;
+        y?: number;
+        animated?: boolean;
+    }) => void;
+    scrollToOffset?: (options: {
+        offset: number;
+        animated?: boolean;
+    }) => void;
+    scrollToLocation?: (options: {
+        sectionIndex: number;
+        itemIndex: number;
+        animated?: boolean;
+        viewOffset?: number;
+    }) => void;
+    getNativeScrollRef?: () => unknown;
+    getInnerViewRef?: () => unknown;
+    props?: any;
+    _listRef?: any;
+};
+/**
+ * Collect scrollable ancestors of `fiber`, innermost first.
+ * Never throws — missing / renamed internals simply yield an empty list.
+ */
+export declare function findScrollAncestors(fiber: AnyFiber): ScrollAncestor[];
+//# sourceMappingURL=findScrollAncestors.d.ts.map

package/lib/typescript/module/src/anchors/fiber/findScrollAncestors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findScrollAncestors.d.ts","sourceRoot":"","sources":["../../../../../../src/anchors/fiber/findScrollAncestors.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACL,KAAK,QAAQ,EASd,MAAM,kBAAkB,CAAC;AAc1B,MAAM,WAAW,cAAc;IAC7B,4EAA4E;IAC5E,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,2EAA2E;IAC3E,cAAc,EAAE,QAAQ,GAAG,IAAI,CAAC;IAChC,oFAAoF;IACpF,YAAY,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC9B,6DAA6D;IAC7D,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAC;IAC7E,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAC;IAC3E,gBAAgB,CAAC,EAAE,CAAC,OAAO,EAAE;QAC3B,YAAY,EAAE,MAAM,CAAC;QACrB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,KAAK,IAAI,CAAC;IACX,kBAAkB,CAAC,EAAE,MAAM,OAAO,CAAC;IACnC,eAAe,CAAC,EAAE,MAAM,OAAO,CAAC;IAEhC,KAAK,CAAC,EAAE,GAAG,CAAC;IAEZ,QAAQ,CAAC,EAAE,GAAG,CAAC;CAChB,CAAC;AAEF;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,QAAQ,GAAG,cAAc,EAAE,CAwBrE"}

package/lib/typescript/module/src/anchors/fiber/measureHostFiber.d.ts

@@ -0,0 +1,20 @@
+import type { AnyFiber } from './fiberInternals';
+type MeasureInWindowCallback = (x: number, y: number, width: number, height: number) => void;
+/**
+ * Feature-detected `measureInWindow` for a host fiber. Tries, in order:
+ *
+ * 1. `stateNode.measureInWindow` — Paper host, or materialized Fabric public instance
+ * 2. `nativeFabricUIManager.measureInWindow(stateNode.node, …)` — Fabric without public instance
+ * 3. `stateNode.canonical.publicInstance.measureInWindow`
+ * 4. `UIManager.measureInWindow(nativeTag, …)` — last resort
+ *
+ * Invokes `callback` with zeros when no measurable path is found (callers treat
+ * zero-size as missing).
+ */
+export declare function measureHostFiber(fiber: AnyFiber, callback: MeasureInWindowCallback): void;
+/**
+ * Build an `AnchorHost`-compatible `measureInWindow` bound to a host fiber.
+ */
+export declare function createFiberMeasureInWindow(fiber: AnyFiber): (callback: MeasureInWindowCallback) => void;
+export {};
+//# sourceMappingURL=measureHostFiber.d.ts.map

package/lib/typescript/module/src/anchors/fiber/measureHostFiber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"measureHostFiber.d.ts","sourceRoot":"","sources":["../../../../../../src/anchors/fiber/measureHostFiber.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAGjD,KAAK,uBAAuB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;AAE7F;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,uBAAuB,GAAG,IAAI,CAuDzF;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,QAAQ,GACd,CAAC,QAAQ,EAAE,uBAAuB,KAAK,IAAI,CAI7C"}

package/lib/typescript/module/src/anchors/fiber/visibleScreens.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Restricts anchor scanning to the screens a user can actually see.
+ *
+ * A navigator keeps earlier screens mounted, so without this a tooltip could
+ * anchor to a view on a covered screen — measured on device: with a screen
+ * pushed on top, an anchor on the screen underneath still resolved and measured
+ * to an on-screen rect. Reusing one `testID` across two stacked screens also
+ * degraded to `ambiguous` and failed closed, even though only one was visible.
+ *
+ * Rules, derived from what react-native-screens actually exposes:
+ *
+ * - Native stack (`RNSScreenStack`): every mounted screen reports
+ *   `activityState === 2`, so it is useless as a discriminator. Sibling order
+ *   is what matters — the **last** branch owning a screen is on top.
+ * - Container-style navigators (tabs, non-native stacks) do vary
+ *   `activityState`, so the active branches win. When every branch is active
+ *   (e.g. multi-pane), all stay scannable — we must not fall back to
+ *   last-sibling there, or visible panes get pruned.
+ *
+ * Branches that own no screen at all (tab bars, headers, other global chrome)
+ * are always kept, so anchors outside the screen stack keep resolving.
+ *
+ * Everything is feature-detected: an app without react-native-screens, or a
+ * renamed native component, prunes nothing and behaves as before.
+ */
+import { type AnyFiber } from './fiberInternals';
+export declare function isScreenContainerFiber(fiber: AnyFiber): boolean;
+/**
+ * Branches of `container` that are covered by another screen and so must not be
+ * scanned. Empty when there is nothing to prune. Alternates are included so a
+ * fiber captured on a previous render still matches.
+ */
+export declare function coveredScreenBranches(container: AnyFiber): Set<AnyFiber>;
+/**
+ * Whether `fiber` lives on a screen the user can currently see.
+ *
+ * Needed in addition to scan-time pruning: a resolved anchor is cached, and the
+ * cache would otherwise keep serving a host after its screen was covered by a
+ * newly pushed one. Walks outward so nested navigators are handled.
+ */
+export declare function isFiberOnVisibleScreen(fiber: AnyFiber): boolean;
+//# sourceMappingURL=visibleScreens.d.ts.map

package/lib/typescript/module/src/anchors/fiber/visibleScreens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visibleScreens.d.ts","sourceRoot":"","sources":["../../../../../../src/anchors/fiber/visibleScreens.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,EACL,KAAK,QAAQ,EAQd,MAAM,kBAAkB,CAAC;AAqB1B,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAG/D;AA0CD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,QAAQ,GAAG,GAAG,CAAC,QAAQ,CAAC,CAiCxE;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAyB/D"}

package/lib/typescript/module/src/anchors/hintsCodec.d.ts

@@ -0,0 +1,40 @@
+import type { SemanticSegment } from '@userflow-tech/protocol';
+import { type BuildTimeHints } from './AutoAnchorRegistry';
+/**
+ * Compact build-time hints wire format (v1) emitted by `@userflow-tech/babel-plugin`.
+ * Expanded once at register time so the auto-anchor registry still sees full paths.
+ */
+export declare const COMPACT_HINTS_VERSION: 1;
+export interface CompactBuildTimeHints {
+    v: typeof COMPACT_HINTS_VERSION;
+    /** nativeId (`uf_<hash>`). */
+    n: string;
+    /** Single template / structural path (was ufid + structuralPath + templatePath). */
+    p: string;
+    ct?: string;
+    cs?: string;
+    icn?: string;
+    img?: string;
+    o?: number;
+    si?: number;
+    tid?: string;
+    uid?: string;
+    lid?: string;
+}
+export type HintsInput = BuildTimeHints | CompactBuildTimeHints;
+export declare function isCompactHints(value: unknown): value is CompactBuildTimeHints;
+export declare function isLegacyBuildTimeHints(value: unknown): value is BuildTimeHints;
+/** True when the value is either compact v1 or legacy long-key hints. */
+export declare function isHintsInput(value: unknown): value is HintsInput;
+/**
+ * Parse path segments after `module::Component > …` into ancestor descriptors
+ * (everything except the leaf). Matches Babel `formatSegment` output.
+ */
+export declare function parseAncestorsFromPath(path: string): SemanticSegment[];
+export declare function parsePathSegment(part: string): SemanticSegment | null;
+/**
+ * Expand compact (or legacy) hints into the full `BuildTimeHints` shape used
+ * by AutoAnchorRegistry.
+ */
+export declare function expandBuildTimeHints(input: HintsInput, kind?: string): BuildTimeHints;
+//# sourceMappingURL=hintsCodec.d.ts.map

package/lib/typescript/module/src/anchors/hintsCodec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hintsCodec.d.ts","sourceRoot":"","sources":["../../../../../src/anchors/hintsCodec.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgB,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE7E,OAAO,EAAe,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAExE;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EAAG,CAAU,CAAC;AAEhD,MAAM,WAAW,qBAAqB;IACpC,CAAC,EAAE,OAAO,qBAAqB,CAAC;IAChC,8BAA8B;IAC9B,CAAC,EAAE,MAAM,CAAC;IACV,oFAAoF;IACpF,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,MAAM,MAAM,UAAU,GAAG,cAAc,GAAG,qBAAqB,CAAC;AAEhE,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,qBAAqB,CAQ7E;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,cAAc,CAQ9E;AAED,yEAAyE;AACzE,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAEhE;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,EAAE,CAUtE;AAID,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAerE;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,cAAc,CA+BrF"}

package/lib/typescript/module/src/anchors/resolveAnchorHost.d.ts

@@ -0,0 +1,32 @@
+import { type AnchorHost } from './AnchorRegistry';
+import type { AnyFiber } from './fiber/fiberInternals';
+export type AnchorResolution = {
+    status: 'found';
+    host: AnchorHost;
+    fiber?: AnyFiber;
+} | {
+    status: 'ambiguous';
+} | {
+    status: 'missing';
+};
+/** Invalidate fiber-resolved anchors when the active screen changes. */
+export declare function notifyAnchorScreenChange(screenKey: string | null): void;
+/** Test helper — drop the fiber cache. */
+export declare function clearFiberAnchorCache(): void;
+/**
+ * Resolve a MANUAL anchor id to a measurable host.
+ *
+ * Tier 0: {@link anchorRegistry} (`useUserflowAnchor`) — higher priority, fails
+ * closed on ambiguous registry keys.
+ * Tier 1+: fiber scan for `testID`, then `nativeID`, then `accessibilityLabel`.
+ *
+ * Synchronous (the walk is pure JS; only measurement is async via the returned
+ * host). Caches the resolved fiber per id and revalidates cheaply before reuse.
+ */
+export declare function resolveAnchorHost(id: string): AnchorResolution;
+/**
+ * Drop a cached fiber entry after a zero-size measure so the next resolve
+ * re-scans (the host may have remounted under a new fiber).
+ */
+export declare function invalidateFiberAnchor(id: string): void;
+//# sourceMappingURL=resolveAnchorHost.d.ts.map

package/lib/typescript/module/src/anchors/resolveAnchorHost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveAnchorHost.d.ts","sourceRoot":"","sources":["../../../../../src/anchors/resolveAnchorHost.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAkB,MAAM,kBAAkB,CAAC;AAEnE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAMvD,MAAM,MAAM,gBAAgB,GACxB;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,CAAC,EAAE,QAAQ,CAAA;CAAE,GACvD;IAAE,MAAM,EAAE,WAAW,CAAA;CAAE,GACvB;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,CAAC;AAU1B,wEAAwE;AACxE,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAIvE;AAED,0CAA0C;AAC1C,wBAAgB,qBAAqB,IAAI,IAAI,CAE5C;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,MAAM,GAAG,gBAAgB,CAkD9D;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAEtD"}

package/lib/typescript/module/src/anchors/resolveManualAnchorId.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Resolve a manual tooltip target id from `FlowSelectorFragment.css`.
+ * Web MANUAL fixtures use `#save-button`; strip a leading `#`.
+ */
+export declare function resolveManualAnchorId(css: string | null | undefined): string | null;
+//# sourceMappingURL=resolveManualAnchorId.d.ts.map

package/lib/typescript/module/src/anchors/resolveManualAnchorId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveManualAnchorId.d.ts","sourceRoot":"","sources":["../../../../../src/anchors/resolveManualAnchorId.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAKnF"}

package/lib/typescript/module/src/anchors/scrollAnchorIntoView.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Scroll a tooltip anchor into view by walking fiber scroll ancestors
+ * (or an explicit scroll-container registry override).
+ *
+ * Content offset is derived from two `measureInWindow` calls — container
+ * origin minus content origin — so the host app does not need to wire
+ * `onScroll`. Semantics match web `scrollIntoView({ block: 'nearest' })`:
+ * the minimal delta that brings the padded target fully inside the viewport.
+ */
+import type { Rect } from '../surfaces/tooltip/inferTooltipPlacement';
+import type { AnchorHost } from './AnchorRegistry';
+import type { AnyFiber } from './fiber/fiberInternals';
+import { type ScrollPadding } from './scrollConfig';
+export interface ScrollAnchorIntoViewOptions {
+    /** Measured window rect of the tooltip target. */
+    rect: Rect;
+    /** Measurable host (registry or fiber-backed). */
+    host: AnchorHost;
+    /**
+     * Cached anchor host fiber — enables automatic scroll-ancestor discovery.
+     * When omitted, only the registry / custom / host.scrollIntoView paths run.
+     */
+    fiber?: AnyFiber | null;
+}
+/**
+ * Best-effort scroll so `opts.rect` becomes fully visible.
+ *
+ * Order:
+ * 1. `setCustomScrollIntoView` override (replaces everything)
+ * 2. Explicit `useUserflowScrollContainer` registry (opt-in override)
+ * 3. Fiber scroll-ancestor walk (automatic for testID anchors)
+ * 4. `host.scrollIntoView` (RN Web / DOM)
+ *
+ * Returns `true` when at least one scroll was attempted.
+ */
+export declare function scrollAnchorIntoView(opts: ScrollAnchorIntoViewOptions): boolean;
+/**
+ * Drive every scroll ancestor of `fiber`, innermost first, so nested
+ * scrollers compose correctly.
+ */
+export declare function scrollFiberAncestors(fiber: AnyFiber, target: Rect): boolean;
+/**
+ * Pure helper exported for unit tests: compute the next content offset that
+ * brings `target` fully inside `container` with `block: 'nearest'` semantics.
+ */
+export declare function computeNearestScrollOffset(opts: {
+    target: Rect;
+    container: Rect;
+    contentOffset: {
+        x: number;
+        y: number;
+    };
+    padding?: Partial<ScrollPadding>;
+}): {
+    x: number;
+    y: number;
+    changed: boolean;
+};
+//# sourceMappingURL=scrollAnchorIntoView.d.ts.map

package/lib/typescript/module/src/anchors/scrollAnchorIntoView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scrollAnchorIntoView.d.ts","sourceRoot":"","sources":["../../../../../src/anchors/scrollAnchorIntoView.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,2CAA2C,CAAC;AAEtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAGvD,OAAO,EAA6C,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAK/F,MAAM,WAAW,2BAA2B;IAC1C,kDAAkD;IAClD,IAAI,EAAE,IAAI,CAAC;IACX,kDAAkD;IAClD,IAAI,EAAE,UAAU,CAAC;IACjB;;;OAGG;IACH,KAAK,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC;CACzB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,2BAA2B,GAAG,OAAO,CAqC/E;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,GAAG,OAAO,CAY3E;AAmHD;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE;IAC/C,MAAM,EAAE,IAAI,CAAC;IACb,SAAS,EAAE,IAAI,CAAC;IAChB,aAAa,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACxC,OAAO,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;CAClC,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CA0B7C"}

package/lib/typescript/module/src/anchors/scrollConfig.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Integrator-level scroll configuration, mirroring web userflow.js
+ * `setScrollPadding` / `setCustomScrollIntoView`.
+ */
+import type { Rect } from '../surfaces/tooltip/inferTooltipPlacement';
+export interface ScrollPadding {
+    top?: number;
+    right?: number;
+    bottom?: number;
+    left?: number;
+}
+/** Target passed to a custom scroll-into-view override. */
+export interface ScrollIntoViewTarget {
+    rect: Rect;
+    measureInWindow: (callback: (x: number, y: number, width: number, height: number) => void) => void;
+}
+export type CustomScrollIntoView = (target: ScrollIntoViewTarget) => void;
+/** Sticky header/footer insets applied when deciding whether / how far to scroll. */
+export declare function setScrollPadding(padding: ScrollPadding | null | undefined): void;
+export declare function getScrollPadding(): ScrollPadding | null;
+/**
+ * Replace the SDK's scroll-into-view behavior entirely. Useful for scroll
+ * libraries the fiber walk cannot drive (some FlashList / Reanimated setups).
+ * Pass `null` to restore the default.
+ */
+export declare function setCustomScrollIntoView(fn: CustomScrollIntoView | null | undefined): void;
+export declare function getCustomScrollIntoView(): CustomScrollIntoView | null;
+/** Test helper — reset to defaults. */
+export declare function resetScrollConfig(): void;
+//# sourceMappingURL=scrollConfig.d.ts.map

package/lib/typescript/module/src/anchors/scrollConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scrollConfig.d.ts","sourceRoot":"","sources":["../../../../../src/anchors/scrollConfig.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,2CAA2C,CAAC;AAEtE,MAAM,WAAW,aAAa;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,2DAA2D;AAC3D,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,IAAI,CAAC;IACX,eAAe,EAAE,CACf,QAAQ,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,KACpE,IAAI,CAAC;CACX;AAED,MAAM,MAAM,oBAAoB,GAAG,CAAC,MAAM,EAAE,oBAAoB,KAAK,IAAI,CAAC;AAY1E,qFAAqF;AACrF,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,CAEhF;AAED,wBAAgB,gBAAgB,IAAI,aAAa,GAAG,IAAI,CAEvD;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,oBAAoB,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,CAEzF;AAED,wBAAgB,uBAAuB,IAAI,oBAAoB,GAAG,IAAI,CAErE;AAED,uCAAuC;AACvC,wBAAgB,iBAAiB,IAAI,IAAI,CAGxC"}

package/lib/typescript/module/src/anchors/targetPressMonitor.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Active tooltip target-press subscription.
+ *
+ * {@link TooltipSurface} registers while a TOOLTIP step has a measured target,
+ * non-empty `actions`, and `tooltipTargetBlocked === false`. The bridge reads
+ * this at touch time so rAF measure updates do not re-render the provider.
+ */
+export interface TargetPressRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface TargetPressSubscription {
+    /** Latest measured target bounds (window coordinates). */
+    getRect: () => TargetPressRect | null;
+    /** Runs step.actions — same role as web `onTooltipTargetClick`. */
+    onPress: () => void;
+}
+/** Max finger travel (px) between start and end to count as a tap, not a scroll. */
+export declare const TARGET_PRESS_TAP_SLOP = 10;
+export declare function pointInRect(x: number, y: number, rect: TargetPressRect): boolean;
+export interface TouchPoint {
+    pageX: number;
+    pageY: number;
+}
+/**
+ * True when start and end both land in `rect` and movement stays within tap
+ * slop — mirrors a DOM click on the target without claiming the responder.
+ */
+export declare function isTargetTap(start: TouchPoint, end: TouchPoint, rect: TargetPressRect, slop?: number): boolean;
+/**
+ * Module singleton for the active tooltip target-click listener.
+ * At most one subscription (one visible tooltip step).
+ *
+ * In-progress touches are keyed by native `identifier` so multi-touch start/end
+ * pairs correctly when several fingers are down. RN types `identifier` as
+ * `string`; accept `number | string` for tests and older typings.
+ */
+export type TouchIdentifier = number | string;
+export declare class TargetPressMonitor {
+    private subscription;
+    private touchStarts;
+    set(subscription: TargetPressSubscription | null): void;
+    clear(): void;
+    get(): TargetPressSubscription | null;
+    /** Record touch start for `identifier`; ignores when no active subscription. */
+    handleTouchStart(identifier: TouchIdentifier, pageX: number, pageY: number): void;
+    /**
+     * If the gesture for `identifier` is a tap on the registered target, invoke
+     * `onPress`. Never claims the responder — app controls still receive the press.
+     */
+    handleTouchEnd(identifier: TouchIdentifier, pageX: number, pageY: number): void;
+    /**
+     * Drop in-progress gesture(s). With `identifier`, cancels that finger only;
+     * otherwise clears all (e.g. blanket `onTouchCancel`).
+     */
+    cancelTouch(identifier?: TouchIdentifier): void;
+    /** Test helper. */
+    resetForTests(): void;
+}
+/** Shared singleton used by TooltipSurface and TargetPressBridge. */
+export declare const targetPressMonitor: TargetPressMonitor;
+//# sourceMappingURL=targetPressMonitor.d.ts.map

package/lib/typescript/module/src/anchors/targetPressMonitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"targetPressMonitor.d.ts","sourceRoot":"","sources":["../../../../../src/anchors/targetPressMonitor.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC9B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,uBAAuB;IACtC,0DAA0D;IAC1D,OAAO,EAAE,MAAM,eAAe,GAAG,IAAI,CAAC;IACtC,mEAAmE;IACnE,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAED,oFAAoF;AACpF,eAAO,MAAM,qBAAqB,KAAK,CAAC;AAExC,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,GAAG,OAAO,CAEhF;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,UAAU,EACjB,GAAG,EAAE,UAAU,EACf,IAAI,EAAE,eAAe,EACrB,IAAI,GAAE,MAA8B,GACnC,OAAO,CAMT;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,MAAM,CAAC;AAE9C,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,YAAY,CAAwC;IAC5D,OAAO,CAAC,WAAW,CAA0C;IAE7D,GAAG,CAAC,YAAY,EAAE,uBAAuB,GAAG,IAAI,GAAG,IAAI;IAOvD,KAAK,IAAI,IAAI;IAIb,GAAG,IAAI,uBAAuB,GAAG,IAAI;IAIrC,gFAAgF;IAChF,gBAAgB,CAAC,UAAU,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAQjF;;;OAGG;IACH,cAAc,CAAC,UAAU,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAc/E;;;OAGG;IACH,WAAW,CAAC,UAAU,CAAC,EAAE,eAAe,GAAG,IAAI;IAQ/C,mBAAmB;IACnB,aAAa,IAAI,IAAI;CAItB;AAED,qEAAqE;AACrE,eAAO,MAAM,kBAAkB,oBAA2B,CAAC"}

package/lib/typescript/module/src/anchors/useUserflowAnchor.d.ts

@@ -0,0 +1,30 @@
+import * as React from 'react';
+import type { View } from 'react-native';
+/**
+ * Register a view as a manual Userflow tooltip / embed target.
+ *
+ * Prefer tagging with a plain `testID` (or `nativeID` / `accessibilityLabel`)
+ * on the target view — the SDK resolves those via a fiber-tree scan without a
+ * hook. Use this hook when you need an explicit override (e.g. a third-party
+ * component that does not forward `testID`, or when the same string appears on
+ * multiple views).
+ *
+ * Usage (override):
+ * ```tsx
+ * const anchorRef = useUserflowAnchor('invite-teammates');
+ * return <Pressable ref={anchorRef}>Invite</Pressable>;
+ * ```
+ *
+ * Preferred (no hook):
+ * ```tsx
+ * return <Pressable testID="invite-teammates">Invite</Pressable>;
+ * ```
+ *
+ * When the target can sit inside a scrollable screen, also register the parent
+ * {@link ScrollView} with {@link useUserflowScrollContainer} so off-screen
+ * anchors are scrolled into view before the tooltip places.
+ *
+ * Phase 3 resolves targets via `step.selector.css` (leading `#` stripped).
+ */
+export declare function useUserflowAnchor(id: string): React.RefCallback<View>;
+//# sourceMappingURL=useUserflowAnchor.d.ts.map

package/lib/typescript/module/src/anchors/useUserflowAnchor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUserflowAnchor.d.ts","sourceRoot":"","sources":["../../../../../src/anchors/useUserflowAnchor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAIzC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,MAAM,GAAG,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,CAwDrE"}

package/lib/typescript/module/src/anchors/useUserflowScrollContainer.d.ts

@@ -0,0 +1,34 @@
+import * as React from 'react';
+import type { NativeScrollEvent, NativeSyntheticEvent, ScrollView } from 'react-native';
+export interface UserflowScrollContainerProps {
+    /** Attach to the host ScrollView (or merge with an existing ref). */
+    ref: React.RefCallback<ScrollView>;
+    /** Forward to ScrollView so content offsets stay in sync for scroll-into-view. */
+    onScroll: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
+    /** Required for frequent offset updates while scrolling. */
+    scrollEventThrottle: number;
+}
+/**
+ * Register a host {@link ScrollView} so tooltip anchors can be scrolled into view
+ * when their measured window rect is not fully visible.
+ *
+ * Usually unnecessary — the SDK discovers ScrollView / FlatList ancestors via
+ * the fiber walk for `testID` anchors. Use this hook as an explicit override
+ * for scroll libraries the walk cannot drive, or when the target is only
+ * registered via {@link useUserflowAnchor} without a discoverable fiber.
+ *
+ * Usage:
+ * ```tsx
+ * const scroll = useUserflowScrollContainer();
+ * return (
+ *   <ScrollView {...scroll}>
+ *     <Pressable testID="invite-teammates">Invite</Pressable>
+ *   </ScrollView>
+ * );
+ * ```
+ *
+ * Screen tracking ≠ scroll registration — only ScrollViews you pass through this
+ * hook participate in the registry override path.
+ */
+export declare function useUserflowScrollContainer(onScrollProp?: (event: NativeSyntheticEvent<NativeScrollEvent>) => void): UserflowScrollContainerProps;
+//# sourceMappingURL=useUserflowScrollContainer.d.ts.map

package/lib/typescript/module/src/anchors/useUserflowScrollContainer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUserflowScrollContainer.d.ts","sourceRoot":"","sources":["../../../../../src/anchors/useUserflowScrollContainer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAQxF,MAAM,WAAW,4BAA4B;IAC3C,qEAAqE;IACrE,GAAG,EAAE,KAAK,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;IACnC,kFAAkF;IAClF,QAAQ,EAAE,CAAC,KAAK,EAAE,oBAAoB,CAAC,iBAAiB,CAAC,KAAK,IAAI,CAAC;IACnE,4DAA4D;IAC5D,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,0BAA0B,CACxC,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,oBAAoB,CAAC,iBAAiB,CAAC,KAAK,IAAI,GACtE,4BAA4B,CA2C9B"}

package/lib/typescript/module/src/anonymousId.d.ts

@@ -0,0 +1,5 @@
+/** Matches the web SDK's `userflow:anonymousId` localStorage key. */
+export declare const ANONYMOUS_ID_STORAGE_KEY = "userflow:anonymousId";
+export declare function getOrCreateAnonymousId(): Promise<string>;
+export declare function clearAnonymousId(): Promise<void>;
+//# sourceMappingURL=anonymousId.d.ts.map

package/lib/typescript/module/src/anonymousId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anonymousId.d.ts","sourceRoot":"","sources":["../../../../src/anonymousId.ts"],"names":[],"mappings":"AAGA,qEAAqE;AACrE,eAAO,MAAM,wBAAwB,yBAAyB,CAAC;AAY/D,wBAAsB,sBAAsB,IAAI,OAAO,CAAC,MAAM,CAAC,CAa9D;AAED,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAMtD"}

package/lib/typescript/module/src/content/RichContentRenderer.d.ts

@@ -0,0 +1,21 @@
+import type { FlowActionFragment, FlowButtonFragment, ThemeFragment } from '@userflow-tech/protocol';
+import * as React from 'react';
+import type { JustifyContent, LookupAttribute, RichContentDoc } from './types';
+export interface RichContentRendererProps {
+    content: string | RichContentDoc | null | undefined;
+    buttons: FlowButtonFragment[];
+    theme: ThemeFragment;
+    sessionData: {
+        name: string;
+        value: string | string[];
+    }[];
+    lookupAttribute: LookupAttribute;
+    onActions: (actions: FlowActionFragment[]) => void;
+    /**
+     * Default justify for button-groups when `align` is unset.
+     * Web: modal → center, tooltip/bubble → end.
+     */
+    defaultButtonsAlign?: JustifyContent;
+}
+export declare function RichContentRenderer({ content, buttons, theme, sessionData, lookupAttribute, onActions, defaultButtonsAlign, }: RichContentRendererProps): React.ReactElement;
+//# sourceMappingURL=RichContentRenderer.d.ts.map