@webority/mobile-chat 0.0.0-stage → 0.4.0

package/lib/typescript/module/components/ChatMessage.d.ts

@@ -0,0 +1,35 @@
+import type React from 'react';
+import { type ChatLabels } from '../labels.js';
+import type { ChatRating, SupportActionTicket } from '../types.js';
+import type { ChatTurn } from '../useChat.js';
+/** The props a thread passes to each of its turns. */
+export interface ChatReplyProps<T = string> {
+    /** Shows the rating under a stored reply. */
+    onRate?: (turnId: string, rating: ChatRating, note?: string) => Promise<unknown>;
+    /** Maps a reply link to what it opens; see `ChatMarkdown`. */
+    resolveLink?: (href: string) => T | null | undefined;
+    /** Opens what `resolveLink` returned. */
+    onLinkPress?: (target: T) => void;
+    /** Shows support action cards; see `ActionCard`. */
+    confirmAction?: (token: string) => Promise<SupportActionTicket>;
+    onViewTicket?: (ticket: SupportActionTicket) => void;
+    /**
+     * Draws the assistant's answer in place of `ChatMarkdown` (charts, maths). The question, action
+     * cards, rating and layout stay the library's.
+     */
+    renderReply?: (turn: ChatTurn, state: {
+        streaming: boolean;
+    }) => React.ReactNode;
+    labels?: Partial<ChatLabels>;
+}
+export interface ChatMessageProps<T = string> extends ChatReplyProps<T> {
+    turn: ChatTurn;
+    testID?: string;
+}
+/**
+ * One turn: the person's question on the right, the assistant's answer on the left. The answer is
+ * a polite live region, so a screen reader reads it as it settles. Support actions show under the
+ * answer, and the rating once the reply is stored.
+ */
+export declare function ChatMessage<T = string>({ turn, onRate, resolveLink, onLinkPress, confirmAction, onViewTicket, renderReply, labels: labelOverrides, testID }: ChatMessageProps<T>): React.ReactElement;
+//# sourceMappingURL=ChatMessage.d.ts.map

package/lib/typescript/module/components/ChatScreen.d.ts

@@ -0,0 +1,30 @@
+import type React from 'react';
+import type { UseChatResult } from '../useChat.js';
+import type { ChatReplyProps } from './ChatMessage.js';
+export interface ChatScreenProps<T = string> extends Omit<ChatReplyProps<T>, 'onRate'> {
+    /** The `useChat` result. */
+    chat: UseChatResult;
+    /** Header title. Defaults to the `panelTitle` label. */
+    title?: string;
+    /** Extra header controls before New chat, e.g. an "All chats" button. */
+    headerActions?: React.ReactNode;
+    /** Shown before the first question, in place of the default title and text. */
+    empty?: React.ReactNode;
+    /** The footnote under the question box. Defaults to the `disclaimer` label; null hides it. */
+    disclaimer?: string | null;
+    /** The server's message limit. Default 4000. */
+    maxLength?: number;
+    /** Show the questions left once this many or fewer remain. Default 10. */
+    allowanceThreshold?: number;
+    /** Offer ratings under stored replies. Default true. */
+    rating?: boolean;
+    testID?: string;
+}
+/**
+ * The whole chat for one screen of the app's navigator: a header with New chat, the
+ * conversation, the questions left today, the question box and the AI disclaimer. The question
+ * box rises with the keyboard. Place it in a stack screen (or a full-height sheet) and keep the
+ * `useChat` call above the navigator, so the conversation survives leaving the screen.
+ */
+export declare function ChatScreen<T = string>({ chat, title, headerActions, empty, disclaimer, maxLength, allowanceThreshold, rating, testID, ...reply }: ChatScreenProps<T>): React.ReactElement;
+//# sourceMappingURL=ChatScreen.d.ts.map

package/lib/typescript/module/components/ChatThread.d.ts

@@ -0,0 +1,17 @@
+import type React from 'react';
+import { type StyleProp, type ViewStyle } from 'react-native';
+import type { ChatTurn } from '../useChat.js';
+import { type ChatReplyProps } from './ChatMessage.js';
+export interface ChatThreadProps<T = string> extends ChatReplyProps<T> {
+    turns: ChatTurn[];
+    /** Shown before the first question. */
+    empty?: React.ReactNode;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+/**
+ * The conversation, oldest first, in a scroll view that follows the newest text while an answer
+ * streams and when a question is added.
+ */
+export declare function ChatThread<T = string>({ turns, empty, style, testID, ...reply }: ChatThreadProps<T>): React.ReactElement;
+//# sourceMappingURL=ChatThread.d.ts.map

package/lib/typescript/module/components/ReplyRating.d.ts

@@ -0,0 +1,19 @@
+import type React from 'react';
+import { type ChatLabels } from '../labels.js';
+import type { ChatRating } from '../types.js';
+export interface ReplyRatingProps {
+    /** The rating already saved. */
+    rating?: ChatRating | null;
+    /** Saves a rating; rejects on failure. */
+    onRate: (rating: ChatRating, note?: string) => Promise<unknown>;
+    /** The server's note limit. Default 1000. */
+    noteMaxLength?: number;
+    labels?: Partial<ChatLabels>;
+    testID?: string;
+}
+/**
+ * Helpful and Not helpful under one reply. Either saves at once; Not helpful then offers an
+ * optional note, saved with the same rating. Either choice can be changed.
+ */
+export declare const ReplyRating: React.FC<ReplyRatingProps>;
+//# sourceMappingURL=ReplyRating.d.ts.map

package/lib/typescript/module/index.d.ts

@@ -0,0 +1,28 @@
+export type { ChatClient, ChatHttpClient, ChatHttpRequestConfig } from './client.js';
+export { ChatApiError, createChatClient } from './client.js';
+export type { ActionCardProps } from './components/ActionCard.js';
+export { ActionCard } from './components/ActionCard.js';
+export type { ChatComposerProps } from './components/ChatComposer.js';
+export { ChatComposer } from './components/ChatComposer.js';
+export type { ChatConversationListProps } from './components/ChatConversationList.js';
+export { ChatConversationList } from './components/ChatConversationList.js';
+export type { ChatLauncherProps } from './components/ChatLauncher.js';
+export { ChatLauncher } from './components/ChatLauncher.js';
+export type { ChatMarkdownProps } from './components/ChatMarkdown.js';
+export { ChatMarkdown } from './components/ChatMarkdown.js';
+export type { ChatMessageProps, ChatReplyProps } from './components/ChatMessage.js';
+export { ChatMessage } from './components/ChatMessage.js';
+export type { ChatScreenProps } from './components/ChatScreen.js';
+export { ChatScreen } from './components/ChatScreen.js';
+export type { ChatThreadProps } from './components/ChatThread.js';
+export { ChatThread } from './components/ChatThread.js';
+export type { ReplyRatingProps } from './components/ReplyRating.js';
+export { ReplyRating } from './components/ReplyRating.js';
+export type { ChatLabels } from './labels.js';
+export { DEFAULT_CHAT_LABELS } from './labels.js';
+export type { SseEvent, SseParser } from './sse.js';
+export { createSseParser } from './sse.js';
+export type { ChatRating, ChatRatingInput, ChatStreamEventName, ChatStreamOptions, ChatTurnInput, ChatTurnResult, Conversation, ConversationMessage, ConversationSummary, SupportAction, SupportActionTicket } from './types.js';
+export type { ChatTurn, ChatTurnError, UseChatOptions, UseChatResult } from './useChat.js';
+export { useChat } from './useChat.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/labels.d.ts

@@ -0,0 +1,63 @@
+export interface ChatLabels {
+    launcher: string;
+    panelTitle: string;
+    newChat: string;
+    close: string;
+    thread: string;
+    you: string;
+    assistant: string;
+    thinking: string;
+    emptyTitle: string;
+    emptyText: string;
+    composer: string;
+    placeholder: string;
+    send: string;
+    composerHint: string;
+    allowance: (count: number) => string;
+    disclaimer: string;
+    loadingConversation: string;
+    rateUp: string;
+    rateDown: string;
+    rated: string;
+    ratingNote: string;
+    ratingNoteHint: string;
+    ratingNoteSend: string;
+    ratingNoteSkip: string;
+    ratingFailed: string;
+    actionRaiseTicket: string;
+    actionReply: (ticketNumber: string) => string;
+    actionReopen: (ticketNumber: string) => string;
+    actionNote: string;
+    actionConfirm: string;
+    actionDismiss: string;
+    actionDismissed: string;
+    actionExpired: string;
+    actionFailed: string;
+    actionDoneRaiseTicket: (ticketNumber: string) => string;
+    actionDoneReply: (ticketNumber: string) => string;
+    actionDoneReopen: (ticketNumber: string) => string;
+    viewTicket: string;
+    conversations: string;
+    conversationsEmptyTitle: string;
+    conversationsEmptyText: string;
+    untitled: string;
+    deleteConversation: string;
+    deleteConfirmTitle: string;
+    deleteConfirmMessage: string;
+    deleteConfirm: string;
+    deleteFailed: string;
+    cancel: string;
+    loadMore: string;
+    loadFailed: string;
+    retry: string;
+}
+/**
+ * Every word the chat components show, in English, with the same keys as the web assistant's
+ * labels, so a product passes one label set to both. Pass a `labels` object with any subset to a
+ * component to change its wording; the rest keep these defaults. The few that take a value are
+ * functions. `composerHint` describes a hardware keyboard's Enter key and is not shown on a phone.
+ */
+export declare const DEFAULT_CHAT_LABELS: Readonly<ChatLabels>;
+/** The defaults with a component's `labels` laid over them. */
+export declare const mergeLabels: (labels?: Partial<ChatLabels>) => ChatLabels;
+//# sourceMappingURL=labels.d.ts.map

package/lib/typescript/module/markdownParse.d.ts

@@ -0,0 +1,59 @@
+type BlockShape = {
+    type: 'paragraph';
+    lines: string[];
+} | {
+    type: 'heading';
+    text: string;
+} | {
+    type: 'list';
+    ordered: boolean;
+    start: number;
+    items: string[];
+} | {
+    type: 'table';
+    header: string[];
+    rows: string[][];
+} | {
+    type: 'code';
+    text: string;
+} | {
+    type: 'rule';
+};
+export type MarkdownBlock = BlockShape & {
+    key: number;
+};
+type InlineShape = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'code';
+    text: string;
+} | {
+    type: 'strong' | 'em';
+    children: InlineToken[];
+} | {
+    type: 'link';
+    href: string;
+    children: InlineToken[];
+};
+export type InlineToken = InlineShape & {
+    key: number;
+};
+/**
+ * Splits reply text into blocks: paragraphs, headings, bullet and numbered lists, simple tables,
+ * code blocks and rules. Each block's `key` is its position, so text arriving at the end of a
+ * streaming reply updates the last block in place and never remounts the ones before it.
+ */
+export declare const parseBlocks: (text: string | null | undefined) => MarkdownBlock[];
+/**
+ * Reads bold (`**` or `__`), italics (`*` or `_`), inline code and `[label](href)` links. A marker
+ * with no partner yet (a reply still streaming) shows as the characters typed.
+ */
+export declare const parseInline: (text: string) => InlineToken[];
+/**
+ * What a reply link opens, or null when it may not open anything. Only `scheme:kind/id` hrefs
+ * reach `resolveLink`; a web address never does, so a reply cannot send the person off the app.
+ */
+export declare const linkTarget: <T>(href: string, resolveLink: ((href: string) => T | null | undefined) | undefined) => T | null;
+export {};
+//# sourceMappingURL=markdownParse.d.ts.map

package/lib/typescript/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/module/sse.d.ts

@@ -0,0 +1,23 @@
+export interface SseEvent {
+    /** The `event:` field, or "message" when the block names none. */
+    name: string;
+    /** The `data:` lines joined by newlines and parsed as JSON. */
+    data: unknown;
+}
+export interface SseParser {
+    push: (text: string) => void;
+    end: () => void;
+}
+/**
+ * An incremental reader for a `text/event-stream` body that arrives in pieces. Each `push` takes
+ * the next piece of text; only complete events (ended by a blank line) are handed on, and the
+ * incomplete tail waits for the next piece. `end` flushes a final event the stream closed
+ * without a blank line after.
+ *
+ * Line endings may be `\n`, `\r\n` or `\r`, and a `\r\n` pair may be split across two pieces.
+ * Comment lines (`:`), `id` and `retry` are ignored. A block whose data is not JSON is reported
+ * as an `error` event with the code `invalid-response`, so a caller ends the turn instead of
+ * hanging on it.
+ */
+export declare const createSseParser: (onEvent: (event: SseEvent) => void) => SseParser;
+//# sourceMappingURL=sse.d.ts.map

package/lib/typescript/module/types.d.ts

@@ -0,0 +1,71 @@
+/** An action the assistant prepared for the person to confirm. Nothing happens without the token. */
+export interface SupportAction {
+    token: string;
+    kind: 'RaiseTicket' | 'Reply' | 'Reopen';
+    ticketId: string | null;
+    ticketNumber: string | null;
+    category: string | null;
+    subject: string | null;
+    body: string | null;
+    expiresDateTimeUtc: string;
+}
+/** The ticket a confirmed support action raised, replied on or reopened. */
+export interface SupportActionTicket {
+    id: string;
+    number: string;
+}
+export interface ChatTurnInput {
+    /** The person's question. */
+    message: string;
+    /** The conversation to continue; left out or null to start one. */
+    conversationId?: string | null;
+    /** Product-defined context about the screen, passed through as is. */
+    pageContext?: unknown;
+}
+export type ChatStreamEventName = 'delta' | 'reset' | 'actions';
+export interface ChatStreamOptions {
+    /** Cancels the request. */
+    signal?: AbortSignal;
+    /**
+     * Called for each event before the end of the turn: `delta { text }` to append, `reset {}` to
+     * discard what was shown, `actions { actions }` for support cards.
+     */
+    onEvent?: (name: ChatStreamEventName, data: unknown) => void;
+}
+/** The `done` event: the turn's outcome of record. */
+export interface ChatTurnResult {
+    conversationId: string;
+    /** The stored reply's id, for rating; null when storing failed. */
+    messageId: string | null;
+    /** The reply of record. It replaces whatever was streamed. */
+    reply: string;
+    /** Null when the person has no daily limit. */
+    messagesLeftToday: number | null;
+}
+export interface ConversationSummary {
+    publicId: string;
+    title: string | null;
+    createdDateTimeUtc: string;
+    lastMessageDateTimeUtc: string;
+}
+export interface ConversationMessage {
+    publicId: string;
+    role: 'User' | 'Assistant';
+    content: string;
+    /** The support actions offered with an assistant reply, as a JSON array. */
+    actionsJson: string | null;
+    rating: ChatRating | null;
+    ratingNote: string | null;
+    createdDateTimeUtc: string;
+}
+export interface Conversation {
+    publicId: string;
+    title: string | null;
+    messages: ConversationMessage[];
+}
+export type ChatRating = 'Up' | 'Down';
+export interface ChatRatingInput {
+    rating: ChatRating;
+    note?: string | null;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/module/useChat.d.ts

@@ -0,0 +1,63 @@
+import type { ChatClient } from './client.js';
+import type { ChatRating, SupportAction } from './types.js';
+export interface ChatTurnError {
+    code: string;
+    /** Written for the person. */
+    message: string;
+    resetsAtUtc: string | null;
+}
+/** One question and its answer. */
+export interface ChatTurn {
+    /** Local key; for a reopened conversation, the stored message's id. */
+    id: string;
+    question: string;
+    /** What is shown: the streamed text, then the reply of record. */
+    answer: string;
+    streaming: boolean;
+    error: ChatTurnError | null;
+    actions: SupportAction[];
+    /** The stored reply's id; rating needs it. */
+    messageId: string | null;
+    rating: ChatRating | null;
+    ratingNote: string | null;
+}
+export interface UseChatOptions {
+    /** From `createChatClient`. */
+    client: ChatClient;
+    /** Sent with each question; read at the moment of sending. */
+    pageContext?: unknown;
+}
+export interface UseChatResult {
+    /** Oldest first. */
+    turns: ChatTurn[];
+    /** The conversation being continued, or null. */
+    conversationId: string | null;
+    /** From the last answer or `refreshAllowance()`; null with no daily limit. */
+    messagesLeftToday: number | null;
+    /** An answer is arriving. */
+    streaming: boolean;
+    /** `openConversation` is loading. */
+    loading: boolean;
+    /** `openConversation` failed. */
+    loadError: ChatTurnError | null;
+    /** Asks a question. Ignored while an answer is still arriving. */
+    submit: (message: string) => Promise<void>;
+    /** Replaces the thread with a stored conversation. */
+    openConversation: (id: string) => Promise<void>;
+    /** Clears the thread; the next question starts a conversation. */
+    newConversation: () => void;
+    /** Saves a rating, shown at once; a failed save puts the old one back and rejects. */
+    rate: (turnId: string, rating: ChatRating, note?: string) => Promise<void>;
+    /** Reads the questions left today. */
+    refreshAllowance: () => Promise<void>;
+    /** Clears everything, for sign-out or an account switch. */
+    reset: () => void;
+}
+/**
+ * The chat's state and actions, with no store of its own: it lives in the component that calls
+ * it. Call `reset()` when the signed-in person or account changes so nothing of one person's chat
+ * shows to the next. An answer still streaming is cancelled on `reset`, `newConversation`,
+ * `openConversation` and unmount.
+ */
+export declare const useChat: ({ client, pageContext }: UseChatOptions) => UseChatResult;
+//# sourceMappingURL=useChat.d.ts.map

package/package.json

@@ -1,6 +1,95 @@
 {
   "name": "@webority/mobile-chat",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.4.0",
+  "description": "AI assistant chat for Webority React Native apps: a streaming chat client, a store-agnostic chat hook, and the chat screen, thread, composer, past chats, reply rating and support action cards, built on @webority/mobile-ui.",
+  "keywords": [
+    "react-native",
+    "chat",
+    "assistant",
+    "ai",
+    "streaming",
+    "webority"
+  ],
+  "homepage": "https://www.webority.com",
+  "license": "SEE LICENSE IN LICENSE.txt",
+  "author": {
+    "name": "Webority Technologies",
+    "email": "contact@webority.com",
+    "url": "https://www.webority.com"
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./lib/typescript/module/index.d.ts",
+        "default": "./lib/module/index.js"
+      },
+      "require": {
+        "types": "./lib/typescript/commonjs/index.d.ts",
+        "default": "./lib/commonjs/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./lib/commonjs/index.js",
+  "module": "./lib/module/index.js",
+  "react-native": "./lib/module/index.js",
+  "types": "./lib/typescript/commonjs/index.d.ts",
+  "files": [
+    "lib",
+    "!**/__tests__",
+    "!**/*.test.*",
+    "!**/*.spec.*",
+    "!**/*.map"
+  ],
+  "scripts": {
+    "build": "bob build && node ../../scripts/minify-lib.mjs",
+    "clean": "rimraf lib",
+    "lint": "biome lint ./src",
+    "lint:fix": "biome lint --write ./src",
+    "test": "jest",
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "@webority/mobile-core": ">=0.4.0 <0.5.0",
+    "@webority/mobile-ui": ">=0.4.0 <0.5.0",
+    "react": "^19.1.0",
+    "react-native": ">=0.81.0",
+    "react-native-keyboard-controller": ">=1.21.9",
+    "react-native-safe-area-context": ">=5.4.0"
+  },
+  "peerDependenciesMeta": {},
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      [
+        "commonjs",
+        {
+          "esm": true,
+          "sourceMaps": false
+        }
+      ],
+      [
+        "module",
+        {
+          "esm": true,
+          "sourceMaps": false
+        }
+      ],
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  },
+  "devDependencies": {
+    "@webority/mobile-core": "file:../core",
+    "@webority/mobile-ui": "file:../ui"
+  }
+}