@blario/react-native 0.0.0 → 0.1.1

package/dist/backend/identity-proof.d.ts

@@ -0,0 +1,23 @@
+import type { BlarIdentity, IdentityProof, IdentityRefusalReason } from './identity.ts';
+export declare function readJwtExpiry(token: string): number | null;
+export declare class IdentityProofStore {
+    private readonly now;
+    private identity;
+    private cached;
+    private expiresAt;
+    private inFlight;
+    private mintFailure;
+    constructor(now?: () => number);
+    setIdentity(identity: BlarIdentity | null): void;
+    getIdentity(): BlarIdentity | null;
+    hasIdentity(): boolean;
+    canRefresh(): boolean;
+    refusalReason(): IdentityRefusalReason;
+    get(options?: {
+        refresh?: boolean;
+    }): Promise<IdentityProof | null>;
+    private mint;
+    private fromProviderProof;
+    private storeToken;
+    private storeSignature;
+}

package/dist/backend/identity.d.ts

@@ -0,0 +1,27 @@
+export interface BlarIdentityProofInput {
+    externalId?: string;
+    identityToken?: string;
+    identitySignature?: string;
+}
+export type CustomFields = Record<string, string | number | boolean>;
+export interface BlarIdentity {
+    externalId: string;
+    email?: string;
+    name?: string;
+    phone?: string;
+    contactCompany?: string;
+    contactCompanyExternalId?: string;
+    country?: string;
+    identityToken?: string;
+    identitySignature?: string;
+    getProof?: () => Promise<BlarIdentityProofInput>;
+    getIdentityToken?: () => Promise<string>;
+    getIdentitySignature?: () => Promise<string>;
+    customFields?: CustomFields;
+}
+export interface IdentityProof {
+    header: 'X-Identity-Token' | 'X-Identity-Signature';
+    value: string;
+    protocol: string;
+}
+export type IdentityRefusalReason = 'provider_failed' | 'static_token_expired' | 'identify_refused' | 'subject_mismatch';

package/dist/backend/message-metadata.d.ts

@@ -0,0 +1,19 @@
+import type { TextDomResponseData } from '../agent/frames.ts';
+import type { Size } from '../host/rect.ts';
+import type { AppInfo } from './app-info.ts';
+export interface MessageMetadata extends AppInfo {
+    url: string;
+    tab_id: string;
+    debug_context: {
+        viewport: Size;
+    };
+    text_dom?: TextDomResponseData;
+}
+export interface MessageMetadataInput {
+    screen: string;
+    tabId: string;
+    viewport: Size;
+    appInfo: AppInfo;
+    textDom: TextDomResponseData | null;
+}
+export declare function buildMessageMetadata(input: MessageMetadataInput): MessageMetadata;

package/dist/backend/presence.d.ts

@@ -0,0 +1,20 @@
+import type { ApiClient } from './api-client.ts';
+export declare class PresenceManager {
+    private readonly api;
+    private readonly onPendingNudge;
+    private readonly log;
+    private readonly now;
+    private timer;
+    private subscription;
+    private lastInteraction;
+    private inFlight;
+    private started;
+    constructor(api: ApiClient, onPendingNudge?: () => void, log?: (message: string) => void, now?: () => number);
+    start(): void;
+    stop(): void;
+    noteInteraction(): void;
+    isPresent(): boolean;
+    private fireNow;
+    private scheduleNext;
+    private send;
+}

package/dist/backend/response-cache.d.ts

@@ -0,0 +1,9 @@
+export declare class ResponseCache {
+    private readonly now;
+    private readonly frames;
+    constructor(now?: () => number);
+    store(commandId: string, payload: string): void;
+    clear(): void;
+    drain(): string[];
+    private sweep;
+}

package/dist/backend/session-change.d.ts

@@ -0,0 +1,2 @@
+import type { SessionState } from './session.ts';
+export declare function watchSessionChanges(subscribe: (listener: (state: SessionState) => void) => () => void, onChanged: () => void): () => void;

package/dist/backend/session-socket.d.ts

@@ -0,0 +1,49 @@
+import type { IdentityProof } from './identity.ts';
+export type SocketState = 'connecting' | 'connected' | 'reconnecting' | 'disconnected' | 'failed';
+export interface SessionSocketOptions {
+    apiBaseUrl: string;
+    publishableKey: string;
+    tabId: string;
+    getSourceId: () => string | null;
+    getProof: () => Promise<IdentityProof | null> | null;
+    refreshProof: () => Promise<IdentityProof | null>;
+    getLastSeenSeq: () => number;
+    onMessage: (raw: string, frame: Record<string, unknown> | null) => void;
+    onState: (state: SocketState) => void;
+    onIdentityRejected: () => void;
+    watchForeground: (onActive: () => void) => () => void;
+}
+export declare class SessionSocket {
+    private readonly options;
+    private socket;
+    private sessionId;
+    private epoch;
+    private attempts;
+    private intentionallyClosed;
+    private identityRefreshUsed;
+    private exhausted;
+    private lastFrameAt;
+    private reconnectTimer;
+    private livenessTimer;
+    private stopWatchingForeground;
+    private readonly cache;
+    private cacheScope;
+    constructor(options: SessionSocketOptions);
+    connect(sessionId: number): void;
+    disconnect(): void;
+    isOpen(): boolean;
+    send(payload: string): boolean;
+    sendOrCache(commandId: string, payload: string): void;
+    private open;
+    private handleClose;
+    private handleIdentityRejection;
+    private scheduleReconnect;
+    private recover;
+    private watchForeground;
+    private startLiveness;
+    private stopLiveness;
+    private dropStaleSocket;
+    private discardSocket;
+    private detach;
+    private clearTimers;
+}

package/dist/backend/session.d.ts

@@ -0,0 +1,39 @@
+import type { ApiClient } from './api-client.ts';
+import type { BlarIdentity } from './identity.ts';
+import type { KeyValueStorage } from './storage.ts';
+export interface SessionState {
+    sourceId: string | null;
+    sessionId: number | null;
+    conversationId: number | null;
+    aiActive: boolean;
+    identified: boolean;
+    isIdentityVerified: boolean;
+}
+type Listener = (state: SessionState) => void;
+export declare class BackendSession {
+    private readonly api;
+    private readonly storage;
+    private state;
+    private readonly listeners;
+    private restoring;
+    private readonly storageKey;
+    constructor(api: ApiClient, storage: KeyValueStorage);
+    getState(): SessionState;
+    subscribe(listener: Listener): () => void;
+    boot(identity: BlarIdentity | null): Promise<void>;
+    setUser(identity: BlarIdentity): Promise<void>;
+    private identify;
+    logout(): Promise<void>;
+    refresh(): Promise<SessionState>;
+    adoptSession(sessionId: number): void;
+    leaveSession(): void;
+    ensureSessionId(): Promise<number | null>;
+    private loadAnonymous;
+    private restoreSession;
+    private restore;
+    private fallBackToAnonymous;
+    private dropSource;
+    private apply;
+    private update;
+}
+export {};

package/dist/backend/socket-url.d.ts

@@ -0,0 +1,9 @@
+export interface SocketUrlParts {
+    apiBaseUrl: string;
+    sessionId: number;
+    publishableKey: string;
+    sourceId: string;
+    tabId: string;
+    lastSeenSeq: number;
+}
+export declare function buildSocketUrl(parts: SocketUrlParts): string | null;

package/dist/backend/storage.d.ts

@@ -0,0 +1,13 @@
+export interface KeyValueStorage {
+    getItem: (key: string) => Promise<string | null>;
+    setItem: (key: string, value: string) => Promise<void>;
+    removeItem: (key: string) => Promise<void>;
+}
+declare class MemoryStorage implements KeyValueStorage {
+    private readonly values;
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+}
+export declare function createDefaultStorage(): KeyValueStorage;
+export { MemoryStorage };

package/dist/backend/tab-id.d.ts

@@ -0,0 +1,2 @@
+export declare function getTabId(): string;
+export declare function generateIdempotencyKey(): string;

package/dist/blar.d.ts

@@ -0,0 +1,37 @@
+import type { BackendTransport } from './backend/backend-transport.ts';
+import type { BlarIdentity } from './backend/identity.ts';
+import type { MessageMetadata } from './backend/message-metadata.ts';
+export interface MessageMetadataOptions {
+    includeTextDom: boolean;
+}
+export interface ChatControls {
+    open: () => void;
+    close: () => void;
+    getUnread: () => number;
+    isOpen: () => boolean;
+}
+export type MessageMetadataReader = (options: MessageMetadataOptions) => Promise<MessageMetadata | null>;
+declare class BlarClient {
+    private transport;
+    private metadataReader;
+    private chat;
+    private pendingUser;
+    private logoutRequested;
+    attach(transport: BackendTransport, metadataReader: MessageMetadataReader): void;
+    detach(transport: BackendTransport): void;
+    attachChat(controls: ChatControls): void;
+    detachChat(controls: ChatControls): void;
+    open(): void;
+    close(): void;
+    getUnreadCount(): number;
+    isChatOpen(): boolean;
+    setUser(identity: BlarIdentity): Promise<void>;
+    logout(): Promise<void>;
+    consumePendingUser(): BlarIdentity | null;
+    isConnected(): boolean;
+    getTabId(): string | null;
+    getSessionState(): ReturnType<BackendTransport['getState']> | null;
+    getMessageMetadata(options?: MessageMetadataOptions): Promise<MessageMetadata | null>;
+}
+export declare const Blar: BlarClient;
+export {};

package/dist/chat/ChatLayer.d.ts

@@ -0,0 +1,29 @@
+import React from 'react';
+import type { WidgetProof } from '../backend/backend-transport.ts';
+import type { BlarIdentity } from '../backend/identity.ts';
+import type { MessageMetadata } from '../backend/message-metadata.ts';
+import type { Language, UiStrings } from '../ui/strings.ts';
+import type { ChatSnapshot } from './chat-coordinator.ts';
+import type { ResolvedChatOptions } from './options.ts';
+export interface ChatLayerProps {
+    snapshot: ChatSnapshot;
+    options: ResolvedChatOptions;
+    strings: UiStrings;
+    language: Language;
+    publishableKey: string;
+    apiBaseUrl: string;
+    tabId: string;
+    identity: BlarIdentity | null;
+    getMetadata: (options: {
+        includeTextDom: boolean;
+    }) => Promise<MessageMetadata | null>;
+    getProof: () => Promise<WidgetProof | null>;
+    onOpen: () => void;
+    onClose: () => void;
+    onSessionChanged: (sessionId: number | null) => void;
+    onAcceptNudge: () => void;
+    onDeclineNudge: () => void;
+    onSnoozeNudge: () => void;
+    log?: (message: string) => void;
+}
+export declare function ChatLayer(props: ChatLayerProps): React.JSX.Element;

package/dist/chat/ChatSheet.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { UiStrings } from '../ui/strings.ts';
+import type { SheetMode } from './chat-state.ts';
+export interface ChatSheetProps {
+    mode: SheetMode;
+    mounted: boolean;
+    strings: UiStrings;
+    onClose: () => void;
+    children: React.ReactNode;
+}
+export declare function ChatSheet({ mode, mounted, strings, onClose, children }: ChatSheetProps): React.JSX.Element | null;

package/dist/chat/ChatView.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import type { WidgetProof } from '../backend/backend-transport.ts';
+import type { MessageMetadata } from '../backend/message-metadata.ts';
+import type { SessionRequest } from './chat-coordinator.ts';
+import { type WidgetShellOptions } from './widget-shell.ts';
+export interface ChatViewProps {
+    shell: WidgetShellOptions;
+    unavailableText: string;
+    getMetadata: (options: {
+        includeTextDom: boolean;
+    }) => Promise<MessageMetadata | null>;
+    getProof: () => Promise<WidgetProof | null>;
+    onClosed: () => void;
+    onSessionChanged: (sessionId: number | null) => void;
+    open: boolean;
+    sessionRequest: SessionRequest | null;
+    log?: (message: string) => void;
+}
+export declare function ChatView({ shell, unavailableText, getMetadata, getProof, onClosed, onSessionChanged, open, sessionRequest, log }: ChatViewProps): React.JSX.Element;

package/dist/chat/Launcher.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+export interface LauncherPlacement {
+    side: 'left' | 'right';
+    offsetX: number;
+    offsetY: number;
+}
+export interface LauncherProps {
+    unread: number;
+    label: string;
+    color: string;
+    placement: LauncherPlacement;
+    onPress: () => void;
+}
+export declare function Launcher({ unread, label, color, placement, onPress }: LauncherProps): React.JSX.Element;

package/dist/chat/bridge.d.ts

@@ -0,0 +1,22 @@
+import { type UnknownRecord } from '../fiber/narrow.ts';
+export type NativeCallName = 'metadata' | 'proof';
+export type PageMessage = {
+    kind: 'ready';
+} | {
+    kind: 'closed';
+} | {
+    kind: 'session';
+    sessionId: number | null;
+} | {
+    kind: 'call';
+    id: string;
+    name: NativeCallName;
+    args: UnknownRecord;
+} | {
+    kind: 'log';
+    level: string;
+    text: string;
+};
+export declare function parsePageMessage(raw: string): PageMessage | null;
+export declare function buildResolveScript(id: string, value: unknown, error: string | null): string;
+export declare function buildEventScript(name: string, payload: unknown): string;

package/dist/chat/chat-coordinator.d.ts

@@ -0,0 +1,57 @@
+import { type NudgeView } from '../nudge/nudge.ts';
+import { type ChatState } from './chat-state.ts';
+export interface ChatBackend {
+    getSessionId: () => number | null;
+    openNudge: () => Promise<number | null>;
+    dismissNudge: (milestoneMessageId: number) => Promise<void>;
+    snoozeNudge: (milestoneMessageId: number) => Promise<void>;
+    switchSession: (sessionId: number) => Promise<void>;
+}
+export interface ChatEvents {
+    onSessionReplaced?: () => void;
+}
+export interface SessionRequest {
+    id: number;
+    sessionId: number;
+}
+export interface ChatSnapshot {
+    chat: ChatState;
+    nudge: NudgeView | null;
+    chatKey: number;
+    mounted: boolean;
+    sessionRequest: SessionRequest | null;
+}
+type Listener = (snapshot: ChatSnapshot) => void;
+export declare class ChatCoordinator {
+    private readonly backend;
+    private readonly events;
+    private chat;
+    private nudge;
+    private nudgeLatched;
+    private chatKey;
+    private mounted;
+    private sessionRequest;
+    private snapshot;
+    private readonly listeners;
+    constructor(backend: ChatBackend, events?: ChatEvents);
+    getSnapshot(): ChatSnapshot;
+    subscribe(listener: Listener): () => void;
+    open(): void;
+    close(): void;
+    agentEngaged(): void;
+    agentReleased(): void;
+    handleFrame(frame: Record<string, unknown>): void;
+    acceptNudge(): Promise<void>;
+    declineNudge(): void;
+    snoozeNudge(): void;
+    reset(): void;
+    private followStartedSession;
+    private isVisibleMessage;
+    private surfaceNudge;
+    private reportAndHide;
+    private hideNudge;
+    private dispatch;
+    private publish;
+    private buildSnapshot;
+}
+export {};

package/dist/chat/chat-state.d.ts

@@ -0,0 +1,20 @@
+export type SheetMode = 'closed' | 'open' | 'collapsed';
+export interface ChatState {
+    mode: SheetMode;
+    unread: number;
+    agentWorking: boolean;
+}
+export type ChatEvent = {
+    type: 'open';
+} | {
+    type: 'close';
+} | {
+    type: 'agent_started';
+} | {
+    type: 'agent_finished';
+} | {
+    type: 'message_arrived';
+};
+export declare const INITIAL_CHAT_STATE: ChatState;
+export declare function reduceChat(state: ChatState, event: ChatEvent): ChatState;
+export declare function shouldShowLauncher(state: ChatState): boolean;

package/dist/chat/navigation.d.ts

@@ -0,0 +1,5 @@
+export interface ChatNavigation {
+    url: string;
+    isTopFrame: boolean;
+}
+export declare function leavesChat(navigation: ChatNavigation, documentUrl: string): boolean;

package/dist/chat/options.d.ts

@@ -0,0 +1,22 @@
+import type { LauncherPlacement } from './Launcher.tsx';
+export interface LauncherOptions {
+    visible?: boolean;
+    side?: 'left' | 'right';
+    offsetX?: number;
+    offsetY?: number;
+}
+export interface ChatOptions {
+    enabled?: boolean;
+    launcher?: LauncherOptions;
+    primaryColor?: string;
+    scriptUrl?: string;
+}
+export interface ResolvedChatOptions {
+    enabled: boolean;
+    launcherVisible: boolean;
+    placement: LauncherPlacement;
+    primaryColor: string;
+    widgetColor: string | null;
+    scriptUrl: string | null;
+}
+export declare function resolveChatOptions(options: ChatOptions | undefined): ResolvedChatOptions;

package/dist/chat/webview.d.ts

@@ -0,0 +1,10 @@
+import type { ComponentType, Ref } from 'react';
+import type { WebViewProps } from 'react-native-webview';
+export interface WebViewHandle {
+    injectJavaScript: (script: string) => void;
+    reload: () => void;
+}
+export type WebViewComponent = ComponentType<WebViewProps & {
+    ref?: Ref<WebViewHandle>;
+}>;
+export declare function loadWebView(): WebViewComponent | null;

package/dist/chat/widget-bundle.generated.d.ts

@@ -0,0 +1,2 @@
+export declare const WIDGET_BUNDLE_DIGEST: string | null;
+export declare const WIDGET_BUNDLE: string | null;

package/dist/chat/widget-shell.d.ts

@@ -0,0 +1,24 @@
+export interface ShellIdentity {
+    externalId: string;
+    email?: string;
+    name?: string;
+    phone?: string;
+    contactCompany?: string;
+    contactCompanyExternalId?: string;
+    country?: string;
+    customFields?: Record<string, string | number | boolean>;
+    identityToken?: string;
+    identitySignature?: string;
+    providesProof: boolean;
+}
+export interface WidgetShellOptions {
+    bundle: string | null;
+    scriptUrl: string | null;
+    publishableKey: string;
+    apiBaseUrl: string;
+    language: 'es' | 'en';
+    tabId: string;
+    primaryColor: string | null;
+    identity: ShellIdentity | null;
+}
+export declare function buildWidgetShell(options: WidgetShellOptions): string;

package/dist/confirmation/port.d.ts

@@ -0,0 +1,12 @@
+import type { TargetView } from '../actions/target.ts';
+import type { AgentAction, RiskLevel } from '../actions/types.ts';
+export interface ConfirmationRequest {
+    riskLevel: RiskLevel;
+    action: AgentAction;
+    explanation: string | null;
+    target: TargetView | null;
+}
+export type ConfirmationOutcome = 'confirmed' | 'declined' | 'timed_out';
+export interface ConfirmationPort {
+    confirm: (request: ConfirmationRequest) => Promise<ConfirmationOutcome>;
+}

package/dist/fiber/locate.d.ts

@@ -0,0 +1,7 @@
+import type { Fiber } from './types.ts';
+export interface LocatedFiber {
+    fiber: Fiber;
+    ancestors: Fiber[];
+}
+export declare function locateCurrent(start: Fiber, target: Fiber): LocatedFiber | null;
+export declare function currentRootFiber(anchor: Fiber): Fiber | null;

package/dist/fiber/narrow.d.ts

@@ -0,0 +1,5 @@
+export type UnknownRecord = Record<string, unknown>;
+export type UnknownFunction = (...args: unknown[]) => unknown;
+export declare function isRecord(value: unknown): value is UnknownRecord;
+export declare function isFunction(value: unknown): value is UnknownFunction;
+export declare function nonEmptyString(value: unknown): string | null;

package/dist/fiber/reader.d.ts

@@ -0,0 +1,10 @@
+import { type Fiber, type FiberRoot, type Props } from './types.ts';
+export declare function propsOf(fiber: Fiber): Props;
+export declare function childrenOf(fiber: Fiber): Fiber[];
+export declare function componentName(fiber: Fiber): string;
+export declare function isHostComponent(fiber: Fiber): boolean;
+export declare function isHostText(fiber: Fiber): boolean;
+export declare function hostRootOf(fiber: Fiber): Fiber | null;
+export declare function fiberRootOf(fiber: Fiber): FiberRoot | null;
+export declare function currentHostRoot(fiber: Fiber): Fiber | null;
+export declare function firstHostDescendant(fiber: Fiber): Fiber | null;

package/dist/fiber/text.d.ts

@@ -0,0 +1,4 @@
+import type { Fiber } from './types.ts';
+export declare function normalizeText(value: string): string;
+export declare function collectText(fiber: Fiber, limit: number): string;
+export declare function precedingText(ancestors: Fiber[], fiber: Fiber, limit: number): string;

package/dist/fiber/types.d.ts

@@ -0,0 +1,21 @@
+export type Props = Readonly<Record<string, unknown>>;
+export interface Fiber {
+    tag: number;
+    key: string | null;
+    type: unknown;
+    memoizedProps: unknown;
+    stateNode: unknown;
+    child: Fiber | null;
+    sibling: Fiber | null;
+    return: Fiber | null;
+    alternate: Fiber | null;
+}
+export interface FiberRoot {
+    current: Fiber;
+}
+export declare const FiberTag: {
+    readonly ClassComponent: 1;
+    readonly HostRoot: 3;
+    readonly HostComponent: 5;
+    readonly HostText: 6;
+};

package/dist/host/border-radius.d.ts

@@ -0,0 +1 @@
+export declare function borderRadiusOf(style: unknown): number;

package/dist/host/instance.d.ts

@@ -0,0 +1,9 @@
+import type { Fiber } from '../fiber/types.ts';
+export type MeasureCallback = (x: number, y: number, width: number, height: number) => void;
+export interface HostInstance {
+    measureInWindow: (callback: MeasureCallback) => void;
+    setNativeProps?: (props: Record<string, unknown>) => void;
+    focus?: () => void;
+    blur?: () => void;
+}
+export declare function hostInstanceOf(host: Fiber): HostInstance | null;

package/dist/host/measure.d.ts

@@ -0,0 +1,3 @@
+import type { Fiber } from '../fiber/types.ts';
+import type { Rect } from './rect.ts';
+export declare function measureHost(host: Fiber): Promise<Rect | null>;

package/dist/host/rect.d.ts

@@ -0,0 +1,22 @@
+export interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface Size {
+    width: number;
+    height: number;
+}
+export declare function intersects(first: Rect, second: Rect): boolean;
+export declare function isVisibleIn(rect: Rect, viewport: Size): boolean;
+export declare function centerOf(rect: Rect): Point;
+export interface Band {
+    top: number;
+    bottom: number;
+}
+export declare function scrollDeltaIntoBand(target: Rect, band: Band): number;

package/dist/host/visible-area.d.ts

@@ -0,0 +1,2 @@
+import type { Size } from './rect.ts';
+export declare function visibleViewport(window: Size, keyboardHeight: number): Size;

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { BlarProvider } from './BlarProvider.tsx';
+export type { BlarProviderProps } from './BlarProvider.tsx';
+export { Blar } from './blar.ts';
+export type { ChatControls, MessageMetadataOptions } from './blar.ts';
+export type { ChatOptions, LauncherOptions } from './chat/options.ts';
+export type { Language, UiStringOverrides, UiStrings } from './ui/strings.ts';
+export type { NavigationRefLike } from './actions/navigation-driver.ts';
+export type { BlarIdentity, BlarIdentityProofInput, CustomFields } from './backend/identity.ts';
+export type { MessageMetadata } from './backend/message-metadata.ts';
+export { SDK_VERSION } from './version.ts';