@blario/react-native 0.0.0-stage → 0.1.0

package/dist/nudge/NudgeBubble.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { LauncherPlacement } from '../chat/Launcher.tsx';
+import type { UiStrings } from '../ui/strings.ts';
+import { type NudgeView } from './nudge.ts';
+export interface NudgeBubbleProps {
+    nudge: NudgeView;
+    strings: UiStrings;
+    color: string;
+    placement: LauncherPlacement;
+    launcherVisible: boolean;
+    onAccept: () => void;
+    onDecline: () => void;
+    onLater: () => void;
+}
+export declare function NudgeBubble({ nudge, strings, color, placement, launcherVisible, onAccept, onDecline, onLater }: NudgeBubbleProps): React.JSX.Element;

package/dist/nudge/nudge.d.ts

@@ -0,0 +1,23 @@
+import { type UnknownRecord } from '../fiber/narrow.ts';
+export interface NudgeSender {
+    name: string;
+    subtitle: string | null;
+    avatarUrl: string | null;
+}
+export interface NudgeProgress {
+    total: number;
+    completed: number;
+}
+export interface NudgeView {
+    bubbleMessage: string;
+    continuation: boolean;
+    milestoneMessageId: number | null;
+    sessionId: number | null;
+    sender: NudgeSender | null;
+    progress: NudgeProgress | null;
+    ctaLabel: string | null;
+}
+export declare function parseHistoryNudge(frame: UnknownRecord): NudgeView | null;
+export declare function parseMessageNudge(frame: UnknownRecord, currentSessionId: number | null): NudgeView | null;
+export declare function parseFrameNudge(frame: UnknownRecord, currentSessionId: number | null): NudgeView | null;
+export declare function initialsOf(name: string): string;

package/dist/optional/expo-haptics.d.ts

@@ -0,0 +1 @@
+export declare const EXPO_HAPTICS: unknown;

package/dist/optional/expo-keep-awake.d.ts

@@ -0,0 +1 @@
+export declare const EXPO_KEEP_AWAKE: unknown;

package/dist/optional/react-native-haptic-feedback.d.ts

@@ -0,0 +1 @@
+export declare const REACT_NATIVE_HAPTIC_FEEDBACK: unknown;

package/dist/optional/react-native-keep-awake.d.ts

@@ -0,0 +1 @@
+export declare const REACT_NATIVE_KEEP_AWAKE: unknown;

package/dist/overlay/AgentOverlay.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export interface AgentOverlayProps {
+    children?: React.ReactNode;
+}
+export declare function AgentOverlay({ children }: AgentOverlayProps): React.JSX.Element;

package/dist/screenshot/capture-backend.d.ts

@@ -0,0 +1,6 @@
+import type { ScreenshotOptions } from '../agent/frames.ts';
+export interface CaptureBackend {
+    name: string;
+    capturesModals: boolean;
+    capture: (target: unknown, options: ScreenshotOptions) => Promise<string>;
+}

package/dist/screenshot/screenshotter.d.ts

@@ -0,0 +1,18 @@
+import type { ScreenshotOptions } from '../agent/frames.ts';
+import type { CaptureBackend } from './capture-backend.ts';
+export type ScreenshotResult = {
+    ok: true;
+    dataUrl: string;
+    capturesModals: boolean;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare const CAPTURE_BACKEND: CaptureBackend | null;
+export declare class Screenshotter {
+    private readonly getCaptureTarget;
+    private readonly backend;
+    constructor(getCaptureTarget: () => unknown, backend?: CaptureBackend | null);
+    isAvailable(): boolean;
+    capture(options: ScreenshotOptions): Promise<ScreenshotResult>;
+}

package/dist/screenshot/skia.d.ts

@@ -0,0 +1,35 @@
+import type { CaptureBackend } from './capture-backend.ts';
+interface SkiaImage {
+    width: () => number;
+    height: () => number;
+    encodeToBase64: (format: number, quality: number) => string;
+    dispose: () => void;
+}
+interface SkiaCanvas {
+    drawImageRect: (image: SkiaImage, source: unknown, destination: unknown, paint: unknown) => void;
+}
+interface SkiaSurface {
+    getCanvas: () => SkiaCanvas;
+    flush: () => void;
+    makeImageSnapshot: () => SkiaImage;
+    dispose: () => void;
+}
+export interface SkiaModule {
+    makeImageFromView: (viewRef: {
+        current: unknown;
+    }) => Promise<SkiaImage | null>;
+    ImageFormat: {
+        JPEG: number;
+    };
+    Skia: {
+        Surface: {
+            Make: (width: number, height: number) => SkiaSurface | null;
+        };
+        XYWHRect: (x: number, y: number, width: number, height: number) => unknown;
+        Paint: () => unknown;
+    };
+}
+export declare function isSkiaModule(value: unknown): value is SkiaModule;
+export declare function skiaBackend(skia: SkiaModule, platform: string): CaptureBackend | null;
+export declare const SKIA_MODULE: SkiaModule | null;
+export {};

package/dist/screenshot/view-shot.d.ts

@@ -0,0 +1,2 @@
+import type { CaptureBackend } from './capture-backend.ts';
+export declare const VIEW_SHOT_BACKEND: CaptureBackend | null;

package/dist/snapshot/capture.d.ts

@@ -0,0 +1,36 @@
+import type { Fiber } from '../fiber/types.ts';
+import type { Size } from '../host/rect.ts';
+import type { ScreenRef } from './navigation.ts';
+import { ElementRegistry, type RegisteredElement } from './registry.ts';
+export interface Snapshot {
+    screen: string;
+    routes: string[];
+    text: string;
+    elements: RegisteredElement[];
+    modalOpen: boolean;
+}
+export interface SnapshotDependencies {
+    getAnchorFiber: () => Fiber | null;
+    registry: ElementRegistry;
+    getViewport: () => Size;
+    getExtraRoutes: () => string[];
+}
+export type CaptureMode = 'register' | 'peek';
+export interface TextTreeOptions {
+    viewportOnly: boolean;
+    maxChars: number;
+}
+export interface TextTree {
+    screen: string;
+    text: string;
+}
+export declare class SnapshotCapturer {
+    private readonly dependencies;
+    constructor(dependencies: SnapshotDependencies);
+    capture(mode: CaptureMode): Promise<Snapshot>;
+    captureText(options: TextTreeOptions): Promise<TextTree>;
+    readFocusedScreens(): ScreenRef[];
+    private measureVisible;
+    private assemble;
+    private register;
+}

package/dist/snapshot/classify.d.ts

@@ -0,0 +1,11 @@
+import { type Fiber } from '../fiber/types.ts';
+import type { ElementKind } from './kinds.ts';
+export interface ScrollInstance {
+    scrollTo: (options: {
+        x?: number;
+        y?: number;
+        animated?: boolean;
+    }) => void;
+}
+export declare function scrollInstanceOf(fiber: Fiber): ScrollInstance | null;
+export declare function classify(fiber: Fiber): ElementKind | null;

package/dist/snapshot/collect.d.ts

@@ -0,0 +1,27 @@
+import type { Fiber } from '../fiber/types.ts';
+import type { ElementKind } from './kinds.ts';
+import { type ScreenRef } from './navigation.ts';
+export declare const AGENT_OVERLAY_TEST_ID = "blar-agent-overlay";
+export interface Candidate {
+    kind: ElementKind;
+    fiber: Fiber;
+    host: Fiber;
+    ancestors: Fiber[];
+    scrollContainers: Fiber[];
+}
+export interface TextBlock {
+    host: Fiber;
+    text: string;
+    heading: boolean;
+    ancestors: Fiber[];
+    scrollContainers: Fiber[];
+}
+export interface Collected {
+    candidates: Candidate[];
+    textBlocks: TextBlock[];
+    focusedScreens: ScreenRef[];
+    modalOpen: boolean;
+}
+export declare function collect(root: Fiber): Collected;
+export declare function isOpenModal(fiber: Fiber): boolean;
+export declare function keepInnermostPerHost(candidates: Candidate[]): Candidate[];

package/dist/snapshot/element-context.d.ts

@@ -0,0 +1,9 @@
+import type { ElementContextItem } from '../agent/frames.ts';
+import type { TargetResolver } from '../actions/target.ts';
+import { type Size } from '../host/rect.ts';
+export declare class ElementContextReader {
+    private readonly resolver;
+    private readonly getViewport;
+    constructor(resolver: TargetResolver, getViewport: () => Size);
+    read(agentId: string): Promise<ElementContextItem>;
+}

package/dist/snapshot/icon.d.ts

@@ -0,0 +1,2 @@
+import type { Fiber } from '../fiber/types.ts';
+export declare function iconNameIn(fiber: Fiber): string | null;

package/dist/snapshot/kinds.d.ts

@@ -0,0 +1,3 @@
+export type ElementKind = 'button' | 'text_input' | 'switch' | 'scroll';
+export type IdPrefix = 'btn' | 'inp' | 'scr';
+export declare const ID_PREFIX_BY_KIND: Readonly<Record<ElementKind, IdPrefix>>;

package/dist/snapshot/modals.d.ts

@@ -0,0 +1,2 @@
+import type { Fiber } from '../fiber/types.ts';
+export declare function countOpenModals(fiber: Fiber): number;

package/dist/snapshot/navigation.d.ts

@@ -0,0 +1,14 @@
+import type { Props } from '../fiber/types.ts';
+export interface NavigationLike {
+    navigate: (...args: unknown[]) => void;
+    isFocused: () => boolean;
+    getState?: () => unknown;
+}
+export interface ScreenRef {
+    key: string;
+    name: string;
+    navigation: NavigationLike;
+}
+export declare function screenOf(props: Props): ScreenRef | null;
+export declare function isFocusedScreen(screen: ScreenRef): boolean;
+export declare function routeNamesOf(navigation: NavigationLike): string[];

package/dist/snapshot/ordering.d.ts

@@ -0,0 +1,2 @@
+import type { MeasuredCandidate } from './wrappers.ts';
+export declare function orderForReading(measured: MeasuredCandidate[]): MeasuredCandidate[];

package/dist/snapshot/properties.d.ts

@@ -0,0 +1,14 @@
+import type { Props } from '../fiber/types.ts';
+export interface AccessibilityFlags {
+    disabled: boolean;
+    selected: boolean | null;
+    expanded: boolean | null;
+    checked: boolean | null;
+}
+export declare function explicitLabelOf(props: Props): string | null;
+export declare function testIdOf(props: Props): string | null;
+export declare function roleOf(props: Props): string | null;
+export declare function accessibilityFlagsOf(props: Props): AccessibilityFlags;
+export declare function inputTypeOf(props: Props): string;
+export declare function placeholderOf(props: Props): string | null;
+export declare function textValueOf(props: Props): string | null;

package/dist/snapshot/registry.d.ts

@@ -0,0 +1,16 @@
+import type { Fiber } from '../fiber/types.ts';
+import type { Rect } from '../host/rect.ts';
+import { type ElementKind } from './kinds.ts';
+export interface RegisteredElement {
+    agentId: string;
+    kind: ElementKind;
+    fiber: Fiber;
+    rect: Rect;
+}
+export declare class ElementRegistry {
+    private counters;
+    private entries;
+    begin(): void;
+    register(kind: ElementKind, fiber: Fiber, rect: Rect): RegisteredElement;
+    find(agentId: string): RegisteredElement | null;
+}

package/dist/snapshot/render.d.ts

@@ -0,0 +1,10 @@
+import type { ElementView } from './view.ts';
+export declare function clip(value: string, limit: number): string;
+export declare function twinSignature(view: ElementView): string;
+export declare function countTwins(views: ElementView[]): Map<string, number>;
+export declare function renderLine(view: ElementView, agentId: string | null, twins: number): string;
+export interface SnapshotHeader {
+    screen: string;
+    routes: string[];
+}
+export declare function renderSnapshotText(header: SnapshotHeader, lines: string[]): string;

package/dist/snapshot/route-summary.d.ts

@@ -0,0 +1,3 @@
+import { type ScreenRef } from './navigation.ts';
+export declare function describeScreenPath(focusedScreens: ScreenRef[]): string;
+export declare function describeRoutes(focusedScreens: ScreenRef[], extraPaths: string[]): string[];

package/dist/snapshot/scroll.d.ts

@@ -0,0 +1,15 @@
+import type { Fiber } from '../fiber/types.ts';
+import type { Rect } from '../host/rect.ts';
+export type ScrollDirection = 'up' | 'down' | 'left' | 'right';
+export interface ScrollGeometry {
+    viewport: Rect;
+    content: Rect;
+    horizontal: boolean;
+}
+export declare function isHorizontal(fiber: Fiber): boolean;
+export declare function measureScrollGeometry(scrollFiber: Fiber): Promise<ScrollGeometry | null>;
+export declare function scrollOffsetOf(geometry: ScrollGeometry): number;
+export declare function maxScrollOffsetOf(geometry: ScrollGeometry): number;
+export declare function viewportExtentOf(geometry: ScrollGeometry): number;
+export declare function scrollDirectionsOf(geometry: ScrollGeometry): ScrollDirection[];
+export declare function describeScrollDirections(geometry: ScrollGeometry | null): string;

package/dist/snapshot/text-layout.d.ts

@@ -0,0 +1,8 @@
+import type { Rect } from '../host/rect.ts';
+export interface PositionedText {
+    rect: Rect;
+    text: string;
+    heading: boolean;
+}
+export declare function groupIntoLines(blocks: PositionedText[]): string[];
+export declare function limitCharacters(lines: string[], maxChars: number): string[];

package/dist/snapshot/view.d.ts

@@ -0,0 +1,30 @@
+import type { Fiber } from '../fiber/types.ts';
+import type { Rect } from '../host/rect.ts';
+import type { Offscreen } from './visibility.ts';
+import type { ElementKind } from './kinds.ts';
+export interface ElementView {
+    kind: ElementKind;
+    label: string;
+    icon: string | null;
+    testID: string | null;
+    role: string | null;
+    type: string | null;
+    placeholder: string | null;
+    value: string | null;
+    checked: boolean | null;
+    disabled: boolean;
+    expanded: boolean | null;
+    selected: boolean | null;
+    scroll: string | null;
+    offscreen: Offscreen | null;
+    rect: Rect;
+}
+export interface ViewSource {
+    kind: ElementKind;
+    fiber: Fiber;
+    ancestors: Fiber[];
+    rect: Rect;
+    scroll: string | null;
+    offscreen?: Offscreen | null;
+}
+export declare function buildView(source: ViewSource): ElementView;

package/dist/snapshot/visibility.d.ts

@@ -0,0 +1,17 @@
+import type { Fiber } from '../fiber/types.ts';
+import { type Rect, type Size } from '../host/rect.ts';
+import { type ScrollGeometry } from './scroll.ts';
+export type ScrollGeometries = Map<Fiber, ScrollGeometry | null>;
+export declare function measureScrollGeometries(containers: Iterable<Fiber>): Promise<ScrollGeometries>;
+export type Offscreen = 'above' | 'below' | 'left' | 'right';
+export type Visibility = {
+    kind: 'visible';
+} | {
+    kind: 'offscreen';
+    direction: Offscreen;
+    distance: number;
+} | {
+    kind: 'hidden';
+};
+export declare function classifyVisibility(rect: Rect, window: Size, containers: Fiber[], geometries: ScrollGeometries): Visibility;
+export declare function keepInTextTree(visibility: Visibility, rect: Rect, window: Size, viewportOnly: boolean): boolean;

package/dist/snapshot/wrappers.d.ts

@@ -0,0 +1,11 @@
+import type { Rect } from '../host/rect.ts';
+import type { Candidate } from './collect.ts';
+import type { Offscreen } from './visibility.ts';
+export interface MeasuredCandidate {
+    candidate: Candidate;
+    rect: Rect;
+    offscreen: Offscreen | null;
+    distance: number;
+}
+export declare function dropWrapperDuplicates(measured: MeasuredCandidate[]): MeasuredCandidate[];
+export declare function limitOffscreen(measured: MeasuredCandidate[]): MeasuredCandidate[];

package/dist/telemetry/SdkErrorBoundary.d.ts

@@ -0,0 +1,15 @@
+import React, { Component, type ReactNode } from 'react';
+interface SdkErrorBoundaryProps {
+    context: string;
+    children: ReactNode;
+}
+interface SdkErrorBoundaryState {
+    failed: boolean;
+}
+export declare class SdkErrorBoundary extends Component<SdkErrorBoundaryProps, SdkErrorBoundaryState> {
+    state: SdkErrorBoundaryState;
+    static getDerivedStateFromError(): SdkErrorBoundaryState;
+    componentDidCatch(error: Error): void;
+    render(): React.ReactNode;
+}
+export {};

package/dist/telemetry/build-info.generated.d.ts

@@ -0,0 +1,2 @@
+export declare const SENTRY_DSN: string;
+export declare const SENTRY_ENVIRONMENT: string;

package/dist/telemetry/envelope.d.ts

@@ -0,0 +1,53 @@
+export type StateSnapshot = Record<string, string | number | boolean>;
+export interface StackFrame {
+    function?: string;
+    filename: string;
+    lineno: number;
+    colno: number;
+}
+export interface Breadcrumb {
+    timestamp: number;
+    category: string;
+    message: string;
+    level: 'info';
+}
+export interface ExceptionValue {
+    type: string;
+    value: string;
+    stacktrace: {
+        frames: StackFrame[];
+    };
+}
+export interface SentryEvent {
+    event_id: string;
+    timestamp: number;
+    platform: 'javascript';
+    level: 'error';
+    environment: string;
+    release: string;
+    sdk: {
+        name: string;
+        version: string;
+    };
+    tags: Record<string, string>;
+    user?: {
+        id: string;
+    };
+    contexts: {
+        app_info: StateSnapshot;
+    };
+    fingerprint: string[];
+    exception: {
+        values: ExceptionValue[];
+    };
+    breadcrumbs: {
+        values: Breadcrumb[];
+    };
+}
+export interface ParsedDsn {
+    dsn: string;
+    endpoint: string;
+}
+export declare function parseDsn(dsn: string): ParsedDsn | null;
+export declare function parseStack(stack: string | undefined): StackFrame[];
+export declare function serializeEnvelope(dsn: string, event: SentryEvent, sentAt: string): string;

package/dist/telemetry/reporter.d.ts

@@ -0,0 +1,33 @@
+import { type StateSnapshot } from './envelope.ts';
+export interface ReportIdentity {
+    sourceId: string | null;
+    sessionId: number | null;
+    userExternalId: string | null;
+}
+export interface ReporterOptions {
+    dsn: string;
+    environment: string;
+    release: string;
+    sdkVersion: string;
+    send: (url: string, body: string) => Promise<unknown>;
+    now: () => number;
+    randomHex: (length: number) => string;
+    appInfo: () => StateSnapshot;
+}
+export declare class Reporter {
+    private readonly options;
+    private readonly target;
+    private readonly breadcrumbs;
+    private publishableKey;
+    private identityProvider;
+    private sent;
+    private reporting;
+    constructor(options: ReporterOptions);
+    setPublishableKey(publishableKey: string): void;
+    setIdentityProvider(provider: () => ReportIdentity): void;
+    addBreadcrumb(category: string, message: string): void;
+    report(context: string, error?: unknown): void;
+    private capture;
+    private readIdentity;
+    private deliver;
+}

package/dist/telemetry/scrub.d.ts

@@ -0,0 +1 @@
+export declare function scrubString(value: string): string;

package/dist/telemetry/sdk-reporter.d.ts

@@ -0,0 +1,5 @@
+import { type ReportIdentity } from './reporter.ts';
+export declare function reportSdkError(context: string, error?: unknown): void;
+export declare function recordSdkBreadcrumb(category: string, message: string): void;
+export declare function setReportPublishableKey(publishableKey: string): void;
+export declare function setReportIdentityProvider(provider: () => ReportIdentity): void;

package/dist/transport/connection-options.d.ts

@@ -0,0 +1,18 @@
+export interface ConnectionOptions {
+    publishableKey?: unknown;
+    apiBaseUrl?: unknown;
+    relayUrl?: unknown;
+}
+export type ConnectionConfig = {
+    kind: 'backend';
+    publishableKey: string;
+    apiBaseUrl: string;
+} | {
+    kind: 'relay';
+    relayUrl: string;
+} | {
+    kind: 'disabled';
+};
+export declare function normalizeApiBaseUrl(value: unknown): string | null;
+export declare function normalizeRelayUrl(value: unknown): string | null;
+export declare function resolveConnectionOptions(options: ConnectionOptions, development: boolean): ConnectionConfig;

package/dist/transport/relay-transport.d.ts

@@ -0,0 +1,17 @@
+import type { OutboundFrame } from '../agent/frames.ts';
+import type { AgentTransport } from './transport.ts';
+export declare class RelayTransport implements AgentTransport {
+    private readonly url;
+    private socket;
+    private listener;
+    private reconnectTimer;
+    private attempts;
+    private stopped;
+    constructor(url: string);
+    onMessage(listener: (raw: string) => void): void;
+    start(): void;
+    stop(): void;
+    send(frame: OutboundFrame): void;
+    private connect;
+    private scheduleReconnect;
+}

package/dist/transport/transport.d.ts

@@ -0,0 +1,7 @@
+import type { OutboundFrame } from '../agent/frames.ts';
+export interface AgentTransport {
+    start: () => void;
+    stop: () => void;
+    send: (frame: OutboundFrame) => void;
+    onMessage: (listener: (raw: string) => void) => void;
+}

package/dist/ui/insets.d.ts

@@ -0,0 +1,8 @@
+export interface Insets {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+}
+export declare function fallbackInsets(): Insets;
+export declare function loadInsetsContext(): React.Context<Insets | null> | null;

package/dist/ui/strings.d.ts

@@ -0,0 +1,33 @@
+export type Language = 'es' | 'en';
+export interface UiStrings {
+    confirmStop: string;
+    confirmationTitle: string;
+    confirmProceed: string;
+    confirmProceedDestructive: string;
+    confirmCannotBeUndone: string;
+    chatLauncher: string;
+    chatClose: string;
+    chatUnavailable: string;
+    nudgePrompt: string;
+    nudgeAccept: string;
+    nudgeDecline: string;
+    nudgeLater: string;
+    nudgeDismiss: string;
+    agentThinking: string;
+    agentExecuting: string;
+    agentTakingControl: string;
+    agentStop: string;
+    agentTapStopToControl: string;
+    agentQueued: string;
+    readingSkip: string;
+    actionClick: string;
+    actionType: string;
+    actionCheck: string;
+    actionUncheck: string;
+    actionScrollTo: string;
+    actionPressKey: string;
+    actionFallback: string;
+}
+export type UiStringOverrides = Partial<UiStrings>;
+export declare function resolveLanguage(language: unknown): Language;
+export declare function resolveStrings(language: Language, overrides: UiStringOverrides | undefined): UiStrings;

package/dist/ui/useInsets.d.ts

@@ -0,0 +1,2 @@
+import { type Insets } from './insets.ts';
+export declare function useInsets(): Insets;

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const SDK_VERSION = "0.1.0";