@thelol3882/sapar 0.0.0-stage → 0.3.0

package/dist/core/index.d.ts

@@ -0,0 +1,273 @@
+import { S as SaparControllerOptions, a as SaparController, R as RunnerSnapshot, T as Tour, P as ProgressInput, b as PlatformAdapter, A as AnnouncementTier, L as LocalizedText, c as TourTrigger, d as Placement, e as Platform, f as Announcement, I as InterruptionPolicy, g as TourStatus, h as Interruption, K as KeyValueStore, i as SaparSource, j as Inbox, k as AnchorHandle, l as AnchorRect } from '../types-CHD2pB5X.js';
+export { m as InboxStatus, n as RunnerPhase, o as SaparSnapshot, p as SessionStore, q as TourStep } from '../types-CHD2pB5X.js';
+export { P as Presentation, a as PresentationInput, r as resolvePresentation } from '../presentation-CClsPRT6.js';
+
+declare function createSaparController(options: SaparControllerOptions): SaparController;
+
+interface TourMachineEvents {
+    onProgress(input: ProgressInput): void;
+    onError(error: unknown, context: string): void;
+}
+interface TourMachineOptions {
+    anchorTimeoutMs?: number;
+    presentAnchorTimeoutMs?: number;
+    locales?: readonly string[];
+}
+interface TourMachine {
+    subscribe(listener: () => void): () => void;
+    /** Referentially stable until the state changes. */
+    getSnapshot(): RunnerSnapshot;
+    start(tour: Tour, options: {
+        autoStarted: boolean;
+    }): Promise<void>;
+    next(): Promise<void>;
+    previous(): Promise<void>;
+    skip(): void;
+    finish(): void;
+    /** Every method is a no-op afterwards. */
+    destroy(): void;
+}
+declare function createTourMachine(adapter: PlatformAdapter, events: TourMachineEvents, options?: TourMachineOptions): TourMachine;
+
+declare const DEFAULT_ANCHOR_TIMEOUT_MS = 3000;
+declare const DEFAULT_PRESENT_ANCHOR_TIMEOUT_MS = 300;
+declare const DEFAULT_AUTO_START_TIMEOUT_MS = 10000;
+
+declare const SESSION_CAP_KEY = "sapar.session-interruption-spent";
+declare function hasSpentSessionInterruption(adapter: PlatformAdapter): boolean;
+declare function spendSessionInterruption(adapter: PlatformAdapter): void;
+
+declare function normalizeRoute(route: string | null | undefined, locales: readonly string[]): string;
+declare function routeMatches(pattern: string, route: string, locales: readonly string[]): boolean;
+declare function isValidRoutePattern(pattern: string): boolean;
+
+interface StepDefinition {
+    key: string;
+    anchor?: string;
+    route?: string;
+    title: LocalizedText;
+    body: LocalizedText;
+    placement: Placement;
+    padding: number;
+    required: boolean;
+    advanceOn: 'next' | 'press';
+}
+interface TourDefinition {
+    key: string;
+    revision: number;
+    title: LocalizedText;
+    trigger: TourTrigger;
+    steps: StepDefinition[];
+    /** Platforms the tour is offered on. Absent means all. */
+    platforms?: Platform[];
+}
+interface AnnouncementDefinition {
+    key: string;
+    tier: AnnouncementTier;
+    title: LocalizedText;
+    body: LocalizedText;
+    imageUrl?: string;
+    cta?: {
+        label: LocalizedText;
+        url: string;
+    };
+    /** ISO 8601. */
+    publishedAt: string;
+    tourKey?: string;
+}
+type StepInput = Pick<StepDefinition, 'key' | 'title' | 'body'> & Partial<StepDefinition>;
+type TourInput = Pick<TourDefinition, 'key' | 'title'> & Partial<Omit<TourDefinition, 'steps'>> & {
+    steps: StepInput[];
+};
+type AnnouncementInput = Pick<AnnouncementDefinition, 'key' | 'title' | 'body' | 'publishedAt'> & Partial<AnnouncementDefinition>;
+interface TextLocale {
+    locale: string;
+    fallbackLocale: string;
+}
+/** Grammar for tour, step, announcement and anchor keys. Shared with the backend and the CLI. */
+declare const KEY_PATTERN: RegExp;
+declare function defineTour(input: TourInput): TourDefinition;
+declare function defineAnnouncement(input: AnnouncementInput): AnnouncementDefinition;
+declare function defineAnchors<const Keys extends readonly string[]>(keys: Keys): Keys;
+type AnchorKey<Anchors extends readonly string[]> = Anchors[number];
+declare function resolveText(text: LocalizedText, locale: string, fallbackLocale: string): string;
+declare function resolveTour(tour: TourDefinition, textLocale: TextLocale): Tour;
+declare function resolveAnnouncement(announcement: AnnouncementDefinition, { locale, fallbackLocale }: TextLocale, unread: boolean): Announcement;
+
+declare const DEFAULT_POLICY: InterruptionPolicy;
+interface TourRecord {
+    status: TourStatus;
+    revision: number;
+    lastStepIndex: number;
+    /** Epoch ms of the first report for this (tour, revision). */
+    startedAt: number;
+    dismissedAt: number | null;
+    /** Sticky: once a run counted as an automatic interruption it stays one. */
+    autoStarted: boolean;
+}
+interface InterruptionBudget {
+    policy: InterruptionPolicy;
+    now: number;
+    registeredAt: number | null;
+    lastAutoInterruptionAt: number | null;
+}
+declare function interruptionsAllowed({ policy, now, registeredAt, lastAutoInterruptionAt }: InterruptionBudget): boolean;
+declare function isTourOfferable({ policy, now, state, revision }: {
+    policy: InterruptionPolicy;
+    now: number;
+    state: TourRecord | undefined;
+    revision: number;
+}): boolean;
+interface InterruptionCandidates {
+    /** `undefined` means the host sent no route, which opts out of route triggers. */
+    route: string | undefined;
+    locales: readonly string[];
+    tours: readonly Tour[];
+    stateOf(tour: Tour): TourRecord | undefined;
+    announcements: readonly Announcement[];
+    dismissedKeys: ReadonlySet<string>;
+}
+declare function pickInterruption(budget: InterruptionBudget, candidates: InterruptionCandidates): Interruption | null;
+
+declare function memoryStore(): KeyValueStore;
+
+interface MemorySourceOptions {
+    tours: readonly TourDefinition[];
+    announcements?: readonly AnnouncementDefinition[];
+    storage: KeyValueStore;
+    locale?: string | (() => string);
+    fallbackLocale?: string;
+    /**
+     * Applied to every resolved string at read time, after locale resolution. Lets definitions hold message keys
+     * resolved by a stable function, so the source identity survives a locale switch.
+     */
+    translate?: (text: string) => string;
+    policy?: Partial<InterruptionPolicy>;
+    registeredAt?: Date | string | null;
+    now?: () => number;
+    namespace?: string;
+}
+declare function memorySource(options: MemorySourceOptions): SaparSource;
+
+interface HttpSourceOptions {
+    baseUrl: string;
+    fetch?: typeof fetch;
+    headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+    credentials?: RequestCredentials;
+    locale?: string | (() => string);
+}
+declare class SaparHttpError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+declare function httpSource(options: HttpSourceOptions): SaparSource;
+
+interface WireStep {
+    step_key: string;
+    order: number;
+    /** Empty means a centered step. */
+    anchor_key: string;
+    /** Empty means the current route. */
+    route: string;
+    title: string;
+    body: string;
+    placement: Placement;
+    spotlight_padding: number;
+    is_required: boolean;
+}
+interface WireTour {
+    key: string;
+    revision: number;
+    title: string;
+    trigger: 'manual' | 'route';
+    steps: WireStep[];
+}
+interface WireTourState {
+    status: TourStatus;
+    last_step_index: number;
+    completed_at: string | null;
+    dismissed_at: string | null;
+}
+interface WireTourDetail extends WireTour {
+    state: WireTourState | null;
+}
+interface WireAnnouncement {
+    key: string;
+    tier: AnnouncementTier;
+    title: string;
+    body: string;
+    image_url: string;
+    cta_label: string;
+    cta_url: string;
+    published_at: string | null;
+    tour_key: string | null;
+    is_unread: boolean;
+}
+interface WireInterruption {
+    kind: 'tour' | 'announcement';
+    tour: WireTour | null;
+    announcement: WireAnnouncement | null;
+}
+interface WireInbox {
+    unread_count: number;
+    items: WireAnnouncement[];
+    interruption: WireInterruption | null;
+}
+interface WireProgress {
+    status: TourStatus;
+    step_index: number;
+    auto_started: boolean;
+}
+declare function fromWireTour(tour: WireTour): Tour;
+declare function fromWireAnnouncement(announcement: WireAnnouncement): Announcement;
+declare function fromWireInbox(inbox: WireInbox): Inbox;
+declare function toWireProgress({ status, stepIndex, autoStarted }: ProgressInput): WireProgress;
+
+interface TestAnchorHandle extends AnchorHandle {
+    press(): void;
+    pressListenerCount(): number;
+}
+interface TestAdapterOptions {
+    platform?: Platform;
+    /** Anchors that exist from the start. */
+    anchors?: readonly string[];
+    /** Anchors that resolve only once `showAnchor` is called, or to null on timeout. */
+    delayedAnchors?: readonly string[];
+    route?: string;
+    now?: number;
+    reducedMotion?: boolean;
+    compact?: boolean;
+}
+interface TestAdapter extends PlatformAdapter {
+    anchors: Map<string, TestAnchorHandle>;
+    navigations: string[];
+    scrolls: Array<{
+        handle: AnchorHandle;
+        reducedMotion: boolean;
+    }>;
+    resolveRequests: Array<{
+        key: string;
+        timeoutMs: number;
+    }>;
+    sessionValues: Map<string, string>;
+    showAnchor(key: string): TestAnchorHandle;
+    hideAnchor(key: string): void;
+    setRoute(route: string): void;
+    advanceTime(ms: number): void;
+}
+declare function createTestAdapter(options?: TestAdapterOptions): TestAdapter;
+
+interface SpotlightPathInput {
+    /** Null dims the whole window. */
+    rect: AnchorRect | null;
+    padding: number;
+    radius: number;
+    bounds: {
+        width: number;
+        height: number;
+    };
+}
+/** The bounds with a rounded hole around `rect`; fill it with the even-odd rule so the hole stays click-through. */
+declare function spotlightPath({ rect, padding, radius, bounds }: SpotlightPathInput): string;
+
+export { AnchorHandle, type AnchorKey, AnchorRect, Announcement, type AnnouncementDefinition, type AnnouncementInput, AnnouncementTier, DEFAULT_ANCHOR_TIMEOUT_MS, DEFAULT_AUTO_START_TIMEOUT_MS, DEFAULT_POLICY, DEFAULT_PRESENT_ANCHOR_TIMEOUT_MS, type HttpSourceOptions, Inbox, Interruption, type InterruptionBudget, type InterruptionCandidates, InterruptionPolicy, KEY_PATTERN, KeyValueStore, LocalizedText, type MemorySourceOptions, Placement, Platform, PlatformAdapter, ProgressInput, RunnerSnapshot, SESSION_CAP_KEY, SaparController, SaparControllerOptions, SaparHttpError, SaparSource, type SpotlightPathInput, type StepDefinition, type StepInput, type TestAdapter, type TestAdapterOptions, type TestAnchorHandle, type TextLocale, Tour, type TourDefinition, type TourInput, type TourMachine, type TourMachineEvents, type TourMachineOptions, type TourRecord, TourStatus, TourTrigger, type WireAnnouncement, type WireInbox, type WireInterruption, type WireProgress, type WireStep, type WireTour, type WireTourDetail, type WireTourState, createSaparController, createTestAdapter, createTourMachine, defineAnchors, defineAnnouncement, defineTour, fromWireAnnouncement, fromWireInbox, fromWireTour, hasSpentSessionInterruption, httpSource, interruptionsAllowed, isTourOfferable, isValidRoutePattern, memorySource, memoryStore, normalizeRoute, pickInterruption, resolveAnnouncement, resolveText, resolveTour, routeMatches, spendSessionInterruption, spotlightPath, toWireProgress };

package/dist/core/index.js

@@ -0,0 +1,71 @@
+import {
+  DEFAULT_ANCHOR_TIMEOUT_MS,
+  DEFAULT_AUTO_START_TIMEOUT_MS,
+  DEFAULT_POLICY,
+  DEFAULT_PRESENT_ANCHOR_TIMEOUT_MS,
+  KEY_PATTERN,
+  SESSION_CAP_KEY,
+  SaparHttpError,
+  createSaparController,
+  createTestAdapter,
+  createTourMachine,
+  defineAnchors,
+  defineAnnouncement,
+  defineTour,
+  fromWireAnnouncement,
+  fromWireInbox,
+  fromWireTour,
+  hasSpentSessionInterruption,
+  httpSource,
+  interruptionsAllowed,
+  isTourOfferable,
+  isValidRoutePattern,
+  memorySource,
+  memoryStore,
+  normalizeRoute,
+  pickInterruption,
+  resolveAnnouncement,
+  resolvePresentation,
+  resolveText,
+  resolveTour,
+  routeMatches,
+  spendSessionInterruption,
+  spotlightPath,
+  toWireProgress
+} from "../chunk-FM64UDKJ.js";
+export {
+  DEFAULT_ANCHOR_TIMEOUT_MS,
+  DEFAULT_AUTO_START_TIMEOUT_MS,
+  DEFAULT_POLICY,
+  DEFAULT_PRESENT_ANCHOR_TIMEOUT_MS,
+  KEY_PATTERN,
+  SESSION_CAP_KEY,
+  SaparHttpError,
+  createSaparController,
+  createTestAdapter,
+  createTourMachine,
+  defineAnchors,
+  defineAnnouncement,
+  defineTour,
+  fromWireAnnouncement,
+  fromWireInbox,
+  fromWireTour,
+  hasSpentSessionInterruption,
+  httpSource,
+  interruptionsAllowed,
+  isTourOfferable,
+  isValidRoutePattern,
+  memorySource,
+  memoryStore,
+  normalizeRoute,
+  pickInterruption,
+  resolveAnnouncement,
+  resolvePresentation,
+  resolveText,
+  resolveTour,
+  routeMatches,
+  spendSessionInterruption,
+  spotlightPath,
+  toWireProgress
+};
+//# sourceMappingURL=index.js.map

package/dist/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/expo/index.d.ts

@@ -0,0 +1,189 @@
+export { E as ExpoAdapterOptions, c as createExpoAdapter } from '../adapter-fFZPsINL.js';
+import * as react from 'react';
+import { ComponentRef, RefCallback, Ref, ReactNode } from 'react';
+import * as react_native from 'react-native';
+import { ScrollViewProps, View, GestureResponderEvent, StyleProp, ViewStyle, ViewProps, TextProps, PressableProps, TextStyle } from 'react-native';
+import { p as SessionStore, K as KeyValueStore, l as AnchorRect, d as Placement, k as AnchorHandle } from '../types-CHD2pB5X.js';
+import { T as TourStepState, S as StepAnnouncement, a as StepCount } from '../stepCount-CTYYFWiV.js';
+import { P as Presentation } from '../presentation-CClsPRT6.js';
+
+interface ContainerMeasurement {
+    /** Top edge of the anchor within the scrollable content. */
+    offsetY: number;
+    height: number;
+    viewportHeight: number;
+}
+/** A vertically scrolling parent that tour anchors can be scrolled into view within. */
+interface ScrollContainer {
+    measure(instance: AnchorInstance): Promise<ContainerMeasurement | null>;
+    scrollToOffset(offsetY: number, animated: boolean): void;
+    /** Calls `listener` at most once per frame while the user or the tour scrolls. */
+    subscribeToScroll(listener: () => void): () => void;
+}
+/** The nearest `TourScrollView` above the caller, if any. */
+declare function useTourScrollContainer(): ScrollContainer | null;
+/** A drop-in `ScrollView` whose children's anchors can be scrolled into view by the tour. Vertical only. */
+declare const TourScrollView: react.ForwardRefExoticComponent<ScrollViewProps & react.RefAttributes<react_native.ScrollViewInstance>>;
+
+type AnchorInstance = ComponentRef<typeof View>;
+interface RegisteredAnchor {
+    instance: AnchorInstance;
+    /** The scroll container the anchor lived in when it registered. */
+    container: ScrollContainer | null;
+}
+declare function registerAnchor(key: string, anchor: RegisteredAnchor): () => void;
+declare function getAnchor(key: string): RegisteredAnchor | null;
+/** Resolves `null` on timeout. Woken by registration. */
+declare function waitForAnchor(key: string, timeoutMs: number): Promise<RegisteredAnchor | null>;
+
+/** The part of `@react-native-async-storage/async-storage` the tours use. */
+interface AsyncStorageLike {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+}
+/** The part of a `react-native-mmkv` instance the tours use: `remove` since v4, `delete` before. */
+type MmkvLike = {
+    getString(key: string): string | undefined;
+    set(key: string, value: string): void;
+} & ({
+    remove(key: string): void;
+} | {
+    delete(key: string): void;
+});
+declare const asyncStorageStore: (storage: AsyncStorageLike) => KeyValueStore;
+declare const mmkvStore: (mmkv: MmkvLike) => KeyValueStore;
+/** Lives as long as the JS runtime, which is what an app session is. */
+declare function appSessionStore(): SessionStore;
+
+interface TourAnchorProps {
+    ref: RefCallback<AnchorInstance>;
+    /** Keeps the native node alive on Android so it stays measurable. */
+    collapsable: false;
+    /** Reports presses without taking the responder from the host's own `Pressable`. */
+    onTouchEnd: (event: GestureResponderEvent) => void;
+}
+/** What the anchored view already has: spreading the result would overwrite it, so it is passed in and composed. */
+interface TourAnchorHost {
+    ref?: Ref<AnchorInstance>;
+    onTouchEnd?: (event: GestureResponderEvent) => void;
+}
+/**
+ * Spread the result onto the view a tour step points at: `<Pressable {...useTourAnchor('billing.upgrade')} />`.
+ * A view that has its own `ref` or `onTouchEnd` passes them as `host`; its `onPress` needs no help.
+ */
+declare function useTourAnchor<K extends string = string>(key: K, { ref: hostRef, onTouchEnd: hostOnTouchEnd }?: TourAnchorHost): TourAnchorProps;
+
+interface Size {
+    width: number;
+    height: number;
+}
+interface Insets {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+interface CardPositionInput {
+    /** Null centers the card in the window. */
+    anchor: AnchorRect | null;
+    card: Size;
+    window: Size;
+    placement: Placement;
+    /** Gap between the anchor and the card. */
+    offset: number;
+    /** Space the card must keep clear at each window edge. */
+    insets: Insets;
+}
+interface CardPosition {
+    x: number;
+    y: number;
+    /** False when neither the preferred side of the anchor nor the opposite one has room for the card. */
+    fits: boolean;
+}
+/** Top-left corner for the card: on the preferred side, flipped when it does not fit, and kept inside the insets. */
+declare function computeCardPosition(input: CardPositionInput): CardPosition;
+
+/** Window rect of the anchor; null without a handle or while it cannot be measured. Re-measures when the window resizes or its scroll container scrolls. */
+declare function useAnchorRect(handle: AnchorHandle | null): AnchorRect | null;
+
+interface TourPopoverProps {
+    style?: StyleProp<ViewStyle>;
+    /** Gap between the anchor and the card. */
+    offset?: number;
+    /** Space kept clear at the window edges; pass the safe-area insets and any tab bar height. Default 8 each. */
+    insets?: Partial<Insets>;
+    /**
+     * `'anchored'` puts the card next to the anchor (centred without one), `'sheet'` is a bottom sheet, and
+     * `'auto'` is anchored unless the card does not fit beside the anchor or the window is narrower than the
+     * adapter's `compactBreakpointPx`. Default `'auto'`.
+     */
+    presentation?: Presentation;
+    children?: ReactNode;
+}
+/** Render at the root after `TourSpotlight`. Sits next to the anchor, centred without one, and is a bottom sheet when it does not fit. */
+declare function TourPopover({ offset, insets, presentation, ...rest }: TourPopoverProps): react.JSX.Element | null;
+
+interface TourOverlayProps extends Pick<TourPopoverProps, 'insets' | 'presentation'> {
+    spotlightColor?: string;
+    spotlightStyle?: StyleProp<ViewStyle>;
+    popoverStyle?: StyleProp<ViewStyle>;
+    onClickOutside?: () => void;
+    /** The step card, either directly or built from the running step. */
+    children: ReactNode | ((tourStep: TourStepState) => ReactNode);
+}
+/** Render at the root, inside the provider and after the app content. The Android back button skips the tour. */
+declare function TourOverlay({ spotlightColor, spotlightStyle, popoverStyle, onClickOutside, insets, presentation, children }: TourOverlayProps): react.JSX.Element | null;
+
+interface TourSpotlightProps {
+    /** Colour of the dim layer. */
+    color?: string;
+    style?: StyleProp<ViewStyle>;
+    /** Corner radius of the cutout. */
+    radius?: number;
+    /** Called when the dim layer is pressed. Defaults to skipping the tour. */
+    onClickOutside?: () => void;
+}
+/** Render at the root, inside the provider and after the app content, so it covers the screen. */
+declare function TourSpotlight({ onClickOutside, ...rest }: TourSpotlightProps): react.JSX.Element | null;
+
+interface TourStepRootProps extends ViewProps {
+    /** Text read by screen readers on each step change. */
+    announceStep?: (step: StepAnnouncement) => string;
+}
+declare function Root(props: TourStepRootProps): react.JSX.Element | null;
+declare function Title({ children, ...rest }: TextProps): react.JSX.Element;
+declare function Body({ children, ...rest }: TextProps): react.JSX.Element;
+interface TourStepProgressProps extends Omit<TextProps, 'children'> {
+    /** Defaults to `"{position} / {total}"`. */
+    children?: ReactNode | ((count: StepCount) => ReactNode);
+}
+declare function Progress({ children, ...rest }: TourStepProgressProps): react.JSX.Element;
+interface TourStepButtonProps extends Omit<PressableProps, 'children'> {
+    children?: ReactNode;
+    /** Styles the label; the button itself takes `style`, which may be a function of the pressed state. */
+    textStyle?: StyleProp<TextStyle>;
+}
+interface TourStepNextProps extends TourStepButtonProps {
+    /** Labels for the last step and the others. Ignored when `children` is given. */
+    doneLabel?: ReactNode;
+    nextLabel?: ReactNode;
+    /** Steps that advance when the anchor is pressed hide this button unless set. */
+    showOnPress?: boolean;
+}
+declare function Next({ doneLabel, nextLabel, showOnPress, children, onPress, ...rest }: TourStepNextProps): react.JSX.Element | null;
+declare function Back({ children, onPress, ...rest }: TourStepButtonProps): react.JSX.Element | null;
+declare function Skip({ children, onPress, ...rest }: TourStepButtonProps): react.JSX.Element;
+declare function Close({ children, ...rest }: TourStepButtonProps): react.JSX.Element;
+declare const TourStep: {
+    Root: typeof Root;
+    Title: typeof Title;
+    Body: typeof Body;
+    Progress: typeof Progress;
+    Next: typeof Next;
+    Back: typeof Back;
+    Skip: typeof Skip;
+    Close: typeof Close;
+};
+
+export { type AnchorInstance, type AsyncStorageLike, type CardPosition, type CardPositionInput, type ContainerMeasurement, type Insets, type MmkvLike, Presentation, type RegisteredAnchor, type ScrollContainer, type Size, type TourAnchorProps, TourOverlay, type TourOverlayProps, TourPopover, type TourPopoverProps, TourScrollView, TourSpotlight, type TourSpotlightProps, TourStep, type TourStepButtonProps, type TourStepNextProps, type TourStepProgressProps, type TourStepRootProps, appSessionStore, asyncStorageStore, computeCardPosition, getAnchor, mmkvStore, registerAnchor, useAnchorRect, useTourAnchor, useTourScrollContainer, waitForAnchor };

package/dist/expo/index.js

@@ -0,0 +1,39 @@
+import {
+  TourOverlay,
+  TourPopover,
+  TourScrollView,
+  TourSpotlight,
+  TourStep,
+  appSessionStore,
+  asyncStorageStore,
+  computeCardPosition,
+  createExpoAdapter,
+  getAnchor,
+  mmkvStore,
+  registerAnchor,
+  useAnchorRect,
+  useTourAnchor,
+  useTourScrollContainer,
+  waitForAnchor
+} from "../chunk-ZBVQGMR4.js";
+import "../chunk-VC6XLWM3.js";
+import "../chunk-FM64UDKJ.js";
+export {
+  TourOverlay,
+  TourPopover,
+  TourScrollView,
+  TourSpotlight,
+  TourStep,
+  appSessionStore,
+  asyncStorageStore,
+  computeCardPosition,
+  createExpoAdapter,
+  getAnchor,
+  mmkvStore,
+  registerAnchor,
+  useAnchorRect,
+  useTourAnchor,
+  useTourScrollContainer,
+  waitForAnchor
+};
+//# sourceMappingURL=index.js.map

package/dist/expo/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/expo-router/index.d.ts

@@ -0,0 +1,18 @@
+import { b as PlatformAdapter, S as SaparControllerOptions } from '../types-CHD2pB5X.js';
+import { E as ExpoAdapterOptions } from '../adapter-fFZPsINL.js';
+import * as react from 'react';
+import { ReactNode } from 'react';
+
+type ExpoRouterAdapterOptions = Pick<ExpoAdapterOptions, 'compactBreakpointPx' | 'session'>;
+/** Identity never changes; `options` are read on first render only. */
+declare function useExpoRouterAdapter(options?: ExpoRouterAdapterOptions): PlatformAdapter;
+
+interface ExpoSaparProviderProps extends Omit<SaparControllerOptions, 'adapter'> {
+    children: ReactNode;
+    /** Stop reporting route changes, so tours and announcements are never offered automatically. */
+    disableRouteTriggers?: boolean;
+    adapterOptions?: ExpoRouterAdapterOptions;
+}
+declare function ExpoSaparProvider({ children, disableRouteTriggers, adapterOptions, ...controllerOptions }: ExpoSaparProviderProps): react.JSX.Element;
+
+export { type ExpoRouterAdapterOptions, ExpoSaparProvider, type ExpoSaparProviderProps, useExpoRouterAdapter };

package/dist/expo-router/index.js

@@ -0,0 +1,46 @@
+import {
+  createExpoAdapter
+} from "../chunk-ZBVQGMR4.js";
+import {
+  SaparProvider
+} from "../chunk-VC6XLWM3.js";
+import "../chunk-FM64UDKJ.js";
+
+// src/expo-router/useExpoRouterAdapter.ts
+import { usePathname, useRouter } from "expo-router";
+import { useEffect, useRef, useState } from "react";
+function useExpoRouterAdapter(options = {}) {
+  const router = useRouter();
+  const pathname = usePathname();
+  const latest = useRef({ router, pathname });
+  useEffect(() => {
+    latest.current = { router, pathname };
+  });
+  const [adapter] = useState(
+    () => createExpoAdapter({
+      ...options,
+      navigate: (route) => latest.current.router.push(route),
+      currentRoute: () => latest.current.pathname
+    })
+  );
+  return adapter;
+}
+
+// src/expo-router/ExpoSaparProvider.tsx
+import { usePathname as usePathname2 } from "expo-router";
+import { jsx } from "react/jsx-runtime";
+function ExpoSaparProvider({
+  children,
+  disableRouteTriggers = false,
+  adapterOptions,
+  ...controllerOptions
+}) {
+  const adapter = useExpoRouterAdapter(adapterOptions);
+  const pathname = usePathname2();
+  return /* @__PURE__ */ jsx(SaparProvider, { ...controllerOptions, adapter, route: disableRouteTriggers ? void 0 : pathname, children });
+}
+export {
+  ExpoSaparProvider,
+  useExpoRouterAdapter
+};
+//# sourceMappingURL=index.js.map

package/dist/expo-router/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/expo-router/useExpoRouterAdapter.ts","../../src/expo-router/ExpoSaparProvider.tsx"],"sourcesContent":["import { usePathname, useRouter } from 'expo-router';\nimport { useEffect, useRef, useState } from 'react';\nimport type { PlatformAdapter } from '../core';\nimport { createExpoAdapter, type ExpoAdapterOptions } from '../expo';\n\nexport type ExpoRouterAdapterOptions = Pick<ExpoAdapterOptions, 'compactBreakpointPx' | 'session'>;\n\n/** Identity never changes; `options` are read on first render only. */\nexport function useExpoRouterAdapter(options: ExpoRouterAdapterOptions = {}): PlatformAdapter {\n    const router = useRouter();\n    const pathname = usePathname();\n    const latest = useRef({ router, pathname });\n    useEffect(() => {\n        latest.current = { router, pathname };\n    });\n\n    const [adapter] = useState(() =>\n        createExpoAdapter({\n            ...options,\n            navigate: (route) => latest.current.router.push(route),\n            currentRoute: () => latest.current.pathname,\n        }),\n    );\n    return adapter;\n}\n","import { usePathname } from 'expo-router';\nimport type { ReactNode } from 'react';\nimport type { SaparControllerOptions } from '../core';\nimport { SaparProvider } from '../react';\nimport { useExpoRouterAdapter, type ExpoRouterAdapterOptions } from './useExpoRouterAdapter';\n\nexport interface ExpoSaparProviderProps extends Omit<SaparControllerOptions, 'adapter'> {\n    children: ReactNode;\n    /** Stop reporting route changes, so tours and announcements are never offered automatically. */\n    disableRouteTriggers?: boolean;\n    adapterOptions?: ExpoRouterAdapterOptions;\n}\n\nexport function ExpoSaparProvider({\n    children,\n    disableRouteTriggers = false,\n    adapterOptions,\n    ...controllerOptions\n}: ExpoSaparProviderProps) {\n    const adapter = useExpoRouterAdapter(adapterOptions);\n    const pathname = usePathname();\n\n    return (\n        <SaparProvider {...controllerOptions} adapter={adapter} route={disableRouteTriggers ? undefined : pathname}>\n            {children}\n        </SaparProvider>\n    );\n}\n"],"mappings":";;;;;;;;;AAAA,SAAS,aAAa,iBAAiB;AACvC,SAAS,WAAW,QAAQ,gBAAgB;AAOrC,SAAS,qBAAqB,UAAoC,CAAC,GAAoB;AAC1F,QAAM,SAAS,UAAU;AACzB,QAAM,WAAW,YAAY;AAC7B,QAAM,SAAS,OAAO,EAAE,QAAQ,SAAS,CAAC;AAC1C,YAAU,MAAM;AACZ,WAAO,UAAU,EAAE,QAAQ,SAAS;AAAA,EACxC,CAAC;AAED,QAAM,CAAC,OAAO,IAAI;AAAA,IAAS,MACvB,kBAAkB;AAAA,MACd,GAAG;AAAA,MACH,UAAU,CAAC,UAAU,OAAO,QAAQ,OAAO,KAAK,KAAK;AAAA,MACrD,cAAc,MAAM,OAAO,QAAQ;AAAA,IACvC,CAAC;AAAA,EACL;AACA,SAAO;AACX;;;ACxBA,SAAS,eAAAA,oBAAmB;AAuBpB;AAVD,SAAS,kBAAkB;AAAA,EAC9B;AAAA,EACA,uBAAuB;AAAA,EACvB;AAAA,EACA,GAAG;AACP,GAA2B;AACvB,QAAM,UAAU,qBAAqB,cAAc;AACnD,QAAM,WAAWC,aAAY;AAE7B,SACI,oBAAC,iBAAe,GAAG,mBAAmB,SAAkB,OAAO,uBAAuB,SAAY,UAC7F,UACL;AAER;","names":["usePathname","usePathname"]}

package/dist/next/index.d.ts

@@ -0,0 +1,18 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { b as PlatformAdapter, S as SaparControllerOptions } from '../types-CHD2pB5X.js';
+import { W as WebAdapterOptions } from '../adapter-Y9yB3-q3.js';
+
+type NextSaparAdapterOptions = Pick<WebAdapterOptions, 'compactBreakpointPx' | 'session'>;
+/** Identity never changes; `options` are read on first render only. */
+declare function useNextSaparAdapter(options?: NextSaparAdapterOptions): PlatformAdapter;
+
+interface NextSaparProviderProps extends Omit<SaparControllerOptions, 'adapter'> {
+    children: ReactNode;
+    /** Stop reporting route changes, so tours and announcements are never offered automatically. */
+    disableRouteTriggers?: boolean;
+    adapterOptions?: NextSaparAdapterOptions;
+}
+declare function NextSaparProvider({ children, disableRouteTriggers, adapterOptions, ...controllerOptions }: NextSaparProviderProps): react.JSX.Element;
+
+export { type NextSaparAdapterOptions, NextSaparProvider, type NextSaparProviderProps, useNextSaparAdapter };