@brainfish-ai/components 0.13.6 → 0.13.7

package/dist/components/chat-search/hooks/useAnswerList.d.ts

@@ -0,0 +1,217 @@
+import { ActionInputs, ActionInput, Answer, AnswerBlock, FeedbackResponse, JSONSchema, SearchResult } from '../types';
+export declare const AnswersActions: {
+    readonly SET_ANSWERS: "answers/set_answers";
+    readonly CLEAR_ALL: "answers/clear_all";
+    readonly APPEND_NEW_ANSWER: "answers/create_empty_answer";
+    readonly APPEND_BLOCK: "answers/append_block";
+    readonly APPEND_ANSWER_CHUNK: "answers/append_stream_chunk";
+    readonly SET_SEARCH_RESULTS: "answers/update_search_results";
+    readonly SET_FOLLOW_UP_QUESTIONS: "answers/set_follow_up_questions";
+    readonly COMPLETE_ANSWER: "answers/finish_streaming";
+    readonly SET_ANSWER_ERROR: "answers/set_error_state";
+    readonly SET_USER_FEEDBACK: "answers/set_user_feedback";
+    readonly CLEAR_USER_FEEDBACK: "answers/clear_user_feedback";
+    readonly MARK_AS_UNCERTAIN: "answers/mark_as_uncertain";
+    readonly NO_ARTICLES_FOUND: "answers/no_articles_found";
+    readonly GET_ACTION_INPUTS: "answers/request_action_inputs";
+    readonly INVOKE_ACTION: "answers/invoke_action";
+    readonly ADD_ACTION_BUTTONS: "answers/add_action_buttons";
+};
+type SetAnswers = {
+    type: typeof AnswersActions.SET_ANSWERS;
+    payload: {
+        answers: Answer[];
+    };
+};
+type ClearAll = {
+    type: typeof AnswersActions.CLEAR_ALL;
+};
+type AppendNewAnswer = {
+    type: typeof AnswersActions.APPEND_NEW_ANSWER;
+    payload: {
+        id?: string;
+        query: string;
+    };
+};
+type SetSearchResults = {
+    type: typeof AnswersActions.SET_SEARCH_RESULTS;
+    payload: {
+        searchQueryId: string;
+        results: SearchResult[];
+        index?: number;
+        state?: Answer['state'];
+    };
+};
+type AppendAnswerChunk = {
+    type: typeof AnswersActions.APPEND_ANSWER_CHUNK;
+    payload: {
+        text: string;
+        index?: number;
+    };
+};
+type SetAnswerError = {
+    type: typeof AnswersActions.SET_ANSWER_ERROR;
+    payload: {
+        error: string;
+        index?: number;
+    };
+};
+type SetUserFeedback = {
+    type: typeof AnswersActions.SET_USER_FEEDBACK;
+    payload: {
+        feedback: FeedbackResponse;
+        index?: number;
+    };
+};
+type ClearUserFeedback = {
+    type: typeof AnswersActions.CLEAR_USER_FEEDBACK;
+    payload: {
+        index?: number;
+    };
+};
+type SetFollowUpQuestions = {
+    type: typeof AnswersActions.SET_FOLLOW_UP_QUESTIONS;
+    payload: {
+        questions: string[];
+        index?: number;
+    };
+};
+type AppendBlock = {
+    type: typeof AnswersActions.APPEND_BLOCK;
+    payload: {
+        block: AnswerBlock;
+        index?: number;
+    };
+};
+type CompleteAnswer = {
+    type: typeof AnswersActions.COMPLETE_ANSWER;
+    payload: {
+        index?: number;
+    };
+};
+type MarkAsUncertain = {
+    type: typeof AnswersActions.MARK_AS_UNCERTAIN;
+    payload: {
+        uncertaintyText: string;
+        index?: number;
+    };
+};
+type GetActionInputs = {
+    type: typeof AnswersActions.GET_ACTION_INPUTS;
+    payload: {
+        searchIntentId: string;
+        actionId: string;
+        inputs: ActionInput[];
+        schema: JSONSchema<ActionInputs>;
+        initialValues: ActionInputs;
+        onSubmit: (parameters: ActionInputs) => void;
+        index?: number;
+    };
+};
+type AddActionButtons = {
+    type: typeof AnswersActions.ADD_ACTION_BUTTONS;
+    payload: {
+        searchIntentId: string;
+        actions: Array<{
+            id: string;
+            type: string;
+            action: {
+                version: string;
+                options: {
+                    title?: string;
+                    [key: string]: any;
+                };
+            };
+        }>;
+        index?: number;
+    };
+};
+type InvokeAction = {
+    type: typeof AnswersActions.INVOKE_ACTION;
+    payload: {
+        index?: number;
+    };
+};
+type NoArticlesFound = {
+    type: typeof AnswersActions.NO_ARTICLES_FOUND;
+    payload: {
+        index?: number;
+    };
+};
+export type AnswerListAction = SetAnswers | ClearAll | AppendNewAnswer | SetSearchResults | AppendAnswerChunk | SetAnswerError | SetUserFeedback | ClearUserFeedback | SetFollowUpQuestions | AppendBlock | CompleteAnswer | MarkAsUncertain | InvokeAction | GetActionInputs | AddActionButtons | NoArticlesFound;
+export declare const setAnswers: ({ answers }: {
+    answers: Answer[];
+}) => SetAnswers;
+export declare const clearAll: () => ClearAll;
+export declare const appendNewAnswer: ({ id, query }: {
+    id?: string | undefined;
+    query: string;
+}) => AppendNewAnswer;
+export declare const setSearchResults: ({ searchQueryId, results, index, state, }: {
+    searchQueryId: string;
+    results: SearchResult[];
+    index?: number | undefined;
+    state?: import('../types').AnswerState | undefined;
+}) => SetSearchResults;
+export declare const appendAnswerChunk: ({ text, index }: {
+    text: string;
+    index?: number | undefined;
+}) => AppendAnswerChunk;
+export declare const setAnswerError: ({ error, index }: {
+    error: string;
+    index?: number | undefined;
+}) => SetAnswerError;
+export declare const setUserFeedback: ({ feedback, index }: {
+    feedback: FeedbackResponse;
+    index?: number | undefined;
+}) => SetUserFeedback;
+export declare const clearUserFeedback: ({ index }?: {
+    index?: number | undefined;
+}) => ClearUserFeedback;
+export declare const setFollowUpQuestions: ({ questions, index }: {
+    questions: string[];
+    index?: number | undefined;
+}) => SetFollowUpQuestions;
+export declare const appendBlock: ({ block, index }: {
+    block: AnswerBlock;
+    index?: number | undefined;
+}) => AppendBlock;
+export declare const completeAnswer: ({ index }?: {
+    index?: number | undefined;
+}) => CompleteAnswer;
+export declare const markAsUncertain: ({ uncertaintyText, index }: {
+    uncertaintyText: string;
+    index?: number | undefined;
+}) => MarkAsUncertain;
+export declare const invokeAction: ({ index }?: {
+    index?: number | undefined;
+}) => InvokeAction;
+export declare const noArticlesFound: ({ index }?: {
+    index?: number | undefined;
+}) => NoArticlesFound;
+export declare const getActionInputs: ({ searchIntentId, actionId, inputs, schema, initialValues, onSubmit, index, }: {
+    searchIntentId: string;
+    actionId: string;
+    inputs: ActionInput[];
+    schema: JSONSchema<ActionInputs>;
+    initialValues: ActionInputs;
+    onSubmit: (parameters: ActionInputs) => void;
+    index?: number | undefined;
+}) => GetActionInputs;
+export declare const addActionButtons: ({ searchIntentId, actions, index, }: {
+    searchIntentId: string;
+    actions: {
+        id: string;
+        type: string;
+        action: {
+            version: string;
+            options: {
+                [key: string]: any;
+                title?: string | undefined;
+            };
+        };
+    }[];
+    index?: number | undefined;
+}) => AddActionButtons;
+export declare const useAnswerList: () => [Answer[], import('react').Dispatch<AnswerListAction>];
+export {};

package/dist/components/chat-search/hooks/useConversationId.d.ts

@@ -0,0 +1,5 @@
+export declare const useConversationId: (searchPath?: string) => {
+    conversationId: string | undefined;
+    setConversationId: (id: string) => void;
+    clearConversationId: () => void;
+};

package/dist/components/chat-search/hooks/useConversationLoader.d.ts

@@ -0,0 +1,17 @@
+import { TextConfig } from '../text-config';
+interface UseLoadConversationProps {
+    loadConversationEndpoint: string | undefined;
+    headers?: Record<string, string>;
+    mergedTextConfig: TextConfig;
+}
+/**
+ * Hook to load a conversation by ID.
+ * @param loadConversationEndpoint - The endpoint to use to load the conversation.
+ * @param headers - The headers to use when loading the conversation.
+ * @param mergedTextConfig - The text configuration to use.
+ * @returns The function to load a conversation by ID.
+ */
+export declare const useConversationLoader: ({ loadConversationEndpoint, headers, mergedTextConfig }: UseLoadConversationProps) => {
+    loadConversationById: (conversationId: string) => (() => void) | undefined;
+};
+export {};

package/dist/components/chat-search/hooks/useDarkMode.d.ts

@@ -0,0 +1 @@
+export declare const useDarkMode: () => boolean;

package/dist/components/chat-search/hooks/useIsChatSearchDirty.d.ts

@@ -0,0 +1 @@
+export declare const useIsChatSearchDirty: () => boolean;

package/dist/components/chat-search/hooks/useScrollManager.d.ts

@@ -0,0 +1,5 @@
+import { RefObject } from 'react';
+export declare const useScrollManager: (answerRefs: RefObject<(HTMLDivElement | null)[]>, containerRef: RefObject<HTMLDivElement | null>) => {
+    scrollToLastAnswer: () => void;
+    scrollToAnswer: (index: number) => void;
+};

package/dist/components/chat-search/hooks/useSubscriptionManager.d.ts

@@ -0,0 +1,4 @@
+import { ChatSearchState } from '../types';
+export declare const useSubscriptionManager: () => {
+    subscribeToStateChanges: (callback: (state: ChatSearchState) => void) => () => void;
+};

package/dist/components/chat-search/hooks/useUrlManager.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Manages the URL based on the conversation ID and answers.
+ * @param searchPath - The path to use in the URL.
+ */
+export declare const useUrlManager: (searchPath?: string) => {
+    updateUrlWithConversationId: (conversationId: string) => void;
+    removeConversationIdFromUrl: () => void;
+};

package/dist/components/chat-search/index.d.ts

@@ -0,0 +1,5 @@
+export { default as ChatSearch } from './ChatSearch';
+export type { ChatSearchHandle } from './ChatSearch';
+export type { Answer, ChatSearchProps, Collection, ChatSearchState } from './types';
+export { ChatSearchProvider, useChatSearch } from './ChatSearchContext';
+export * from './hooks/useIsChatSearchDirty';

package/dist/components/chat-search/text-config.d.ts

@@ -0,0 +1,3 @@
+import { TextConfig as TextConfigType } from './types';
+export type TextConfig = TextConfigType;
+export declare const defaultTextConfig: TextConfig;

package/dist/components/chat-search/types.d.ts

@@ -0,0 +1,253 @@
+import { JSONSchemaType } from 'ajv';
+import { FeatureFlags } from '../../lib/feature-flags';
+export type JSONSchema<T> = JSONSchemaType<T>;
+export interface TextConfig {
+    headerText?: string;
+    searchPlaceholder?: string;
+    attachImageText?: string;
+    allDocumentsText?: string;
+    loadingSearchText?: string;
+    loadingAnswerText?: string;
+    errorText?: string;
+    followUpPlaceholder?: string;
+    positiveAnswerText?: string;
+    negativeAnswerText?: string;
+    suggestionsTitle?: string;
+    uncertaintyFallbackText?: Record<string, string>;
+}
+export declare enum ActionType {
+    CallPhone = "call_phone",
+    OpenUrl = "open_url",
+    SendEmail = "send_email",
+    RunCallback = "run_callback"
+}
+export type FeedbackResponse = 'accept' | 'reject';
+export type APIFeedbackResponse = 'positive' | 'negative';
+/**
+ * Defines a URL redirect rule with pattern matching
+ * @example { source: '/knowledge/:id/:path', destination: '/knowledge/test/:path' }
+ */
+export type RedirectRule = {
+    source: string;
+    destination: string;
+};
+export type MarkdownTextBlock = {
+    id: string;
+    type: 'markdown-text';
+    text: string;
+};
+export type ActionButtonsBlock = {
+    id: string;
+    type: 'action-buttons';
+};
+export type ActionInputFormBlock = {
+    id: string;
+    type: 'action-input-form';
+    state: 'ready' | 'processing' | 'completed';
+    actionId: string;
+    initialValues: ActionInputs;
+    schema: ActionInputsSchema;
+    onSubmit?: (inputs: ActionInputs) => void;
+    inputs: ActionInput[];
+};
+export type ActionInput = {
+    name: string;
+    required: boolean;
+    schema: {
+        type: string;
+        title: string;
+        description: string;
+        oneOf?: {
+            const: string;
+            title: string;
+        }[];
+    };
+    type: string;
+    ui: {
+        type: string;
+    };
+};
+export type AnswerBlock = MarkdownTextBlock | ActionButtonsBlock | ActionInputFormBlock;
+export type CreateAnswerBlock = Omit<MarkdownTextBlock, 'id'> | Omit<ActionButtonsBlock, 'id'> | Omit<ActionInputFormBlock, 'id'>;
+export type AnswerState = 'fetching-search-results' | 'fetching-stream' | 'streaming' | 'getting-action-inputs' | 'completed';
+export type ActionClick = {
+    action: NextBestAction;
+    searchQueryId: string;
+    query: string;
+    answer: string;
+};
+export type Action = {
+    id: string;
+    type: ActionType;
+    action: {
+        version: string;
+        options: {
+            title?: string;
+            [key: string]: any;
+        };
+    };
+};
+export interface Answer {
+    id: string;
+    state: AnswerState;
+    question: string;
+    blocks: AnswerBlock[];
+    searchResults?: SearchResult[];
+    followUpQuestions?: string[];
+    searchQueryId?: string;
+    feedback?: FeedbackResponse;
+    isUncertain?: boolean;
+    uncertaintyLanguage?: string | null;
+    uncertaintyFallbackText?: string;
+    searchIntentId?: string;
+    actions?: Action[];
+}
+export type ActionInputValue = string | number | boolean | null;
+export type ActionInputs = Record<string, ActionInputValue>;
+export type ActionInputsSchema = JSONSchemaType<ActionInputs>;
+export type AnswerStreamRequest = {
+    type: 'generate-for-query';
+    searchQueryId: string;
+    conversationId?: string;
+} | {
+    type: 'invoke-action';
+    searchIntentId: string;
+    actionId: string;
+    parameters: ActionInputs;
+    conversationId?: string;
+};
+export type ClientExecutionResult = {
+    success: boolean;
+    data?: Record<string, any>;
+    reason?: string;
+};
+export interface SearchResult {
+    id: string;
+    title: string;
+    url: string;
+}
+export interface SearchResponse {
+    results: SearchResult[];
+    searchQueryId: string;
+    isAgenticResponse?: boolean;
+}
+export interface FollowUpQuestionsResponse {
+    questions: string[];
+}
+export interface Collection {
+    id: string;
+    name: string;
+}
+export interface Suggestion {
+    id: string;
+    question: string;
+    conversationId?: string;
+    messageCount?: number;
+}
+export interface ChatSearchProps {
+    suggestions?: Suggestion[];
+    collections?: Array<{
+        id: string;
+        name: string;
+    }>;
+    selectedCollectionId?: string;
+    onCollectionChange?: (collectionId: string) => void;
+    searchEndpoint: string;
+    answerEndpoint: string;
+    answerStreamEndpoint: string;
+    feedbackEndpoint?: string;
+    feedbackReasonEndpoint?: string;
+    loadConversationEndpoint?: string;
+    followUpQuestionsEndpoint?: string;
+    autocompleteEndpoint?: string;
+    disableFollowUpQuestions?: boolean;
+    disableImageAttachment?: boolean;
+    disableFeedback?: boolean;
+    disclaimer?: string;
+    offset?: number;
+    headers?: Record<string, string>;
+    textConfig?: TextConfig;
+    searchPath?: string;
+    className?: string;
+    onToggleSizeButtonClick?: () => void;
+    trackEvent?: (eventName: string, data?: Record<string, any>) => void;
+    featureFlags?: FeatureFlags;
+    onCloseWidget?: () => void;
+    isWidgetMode?: boolean;
+    nextBestActions?: NextBestAction[];
+    bodyActionButtons?: NextBestAction[];
+    onNextBestActionClick?: ({ action, searchQueryId, query, answer, }: {
+        action: NextBestAction;
+        searchQueryId: string;
+        query: string;
+        answer: string;
+    }) => void;
+    userData?: Record<string, unknown> | null;
+    redirectRules?: RedirectRule[];
+    secretAttributes?: string;
+    allowedRegions?: string[];
+    style?: React.CSSProperties;
+}
+export interface ChatSearchState {
+    showResults: boolean;
+    answers: Answer[];
+    isLoading: boolean;
+    error?: string;
+}
+type TextChunk = {
+    type: 'answer-text-chunk';
+    content: string;
+};
+type GetActionInputs = {
+    type: 'get-action-inputs';
+    schema: ActionInputsSchema;
+    values: Record<string, string | number | boolean | null>;
+    searchIntentId: string;
+    actionId: string;
+    inputs: ActionInput[];
+    actionType: string;
+    actionKey: string;
+};
+export type ActionButtons = {
+    type: 'action-buttons';
+    actions: Array<{
+        id: string;
+        type: string;
+        action: {
+            version: string;
+            options: {
+                title?: string;
+                phoneNumber?: string;
+                to?: string;
+                [key: string]: any;
+            };
+        };
+    }>;
+    searchIntentId: string;
+};
+export type Citations = {
+    type: 'citations';
+    data: SearchResult[];
+};
+export type AnswerStreamEvent = TextChunk | GetActionInputs | ActionButtons | Citations;
+type UrlString = string & {
+    __url: never;
+};
+export declare const validateUrlString: (value: string) => UrlString;
+export declare enum NextBestActionType {
+    Link = "link",
+    Email = "email",
+    Phone = "phone",
+    Callback = "callback",
+    Function = "function"
+}
+export type NextBestAction = {
+    id?: string;
+    label: string;
+    type: NextBestActionType;
+    icon?: string | UrlString;
+    value: any;
+};
+export type SearchQueryAttribute = string | number | boolean | null;
+export type SearchQueryAttributes = Record<string, SearchQueryAttribute>;
+export {};

package/dist/{combobox.d.ts → components/combobox/combobox.d.ts}

@@ -1,18 +1,14 @@
-import * as React_2 from 'react';
-
-export declare function Combobox({ options, defaultValueLabel, placeholder, noResultsLabel, className, onOpenChange, onChange, }: ComboboxProps): React_2.JSX.Element;
-
-export declare interface ComboboxProps {
-    options: {
-        value: string;
-        label: string;
-    }[];
-    defaultValueLabel: string;
-    placeholder: string;
-    noResultsLabel: string;
-    className?: string;
-    onOpenChange?: (open: boolean) => void;
-    onChange?: (value: string) => void;
-}
-
-export { }
+import * as React from 'react';
+export interface ComboboxProps {
+    options: {
+        value: string;
+        label: string;
+    }[];
+    defaultValueLabel: string;
+    placeholder: string;
+    noResultsLabel: string;
+    className?: string;
+    onOpenChange?: (open: boolean) => void;
+    onChange?: (value: string) => void;
+}
+export declare function Combobox({ options, defaultValueLabel, placeholder, noResultsLabel, className, onOpenChange, onChange, }: ComboboxProps): React.JSX.Element;

package/dist/components/combobox/index.d.ts

@@ -0,0 +1 @@
+export * from './combobox';

package/dist/components/data-table/data-table.d.ts

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+import { ColumnDef, Row } from '@tanstack/react-table';
+export type ExtendedColumnDef<TData, TValue = unknown> = ColumnDef<TData, TValue> & {
+    expandedContent?: (row: Row<TData>) => React.ReactNode;
+};
+export interface DataTableProps<TData, TValue> extends React.HTMLAttributes<HTMLDivElement> {
+    columns: ExtendedColumnDef<TData, TValue>[];
+    data: TData[];
+    getRowCanExpand?: (row: Row<TData>) => boolean;
+    className?: string;
+    expandeRowClassName?: string;
+    isLoading?: boolean;
+    skeletonRowCount?: number;
+}
+export declare function DataTable<TData extends Record<string, any> & {
+    id?: string | number;
+}, TValue>({ columns, data, getRowCanExpand, className, expandeRowClassName, isLoading, skeletonRowCount, ...props }: DataTableProps<TData, TValue>): React.JSX.Element;

package/dist/components/data-table/index.d.ts

@@ -0,0 +1,2 @@
+export { DataTable } from './data-table';
+export type { DataTableProps, ExtendedColumnDef } from './data-table';

package/dist/{date-picker.d.ts → components/date-picker/date-picker.d.ts}

@@ -1,12 +1,9 @@
-import * as React_2 from 'react';
-
-export declare function DatePicker({ date, setDate, className, placeholder }: DatePickerProps): React_2.JSX.Element;
-
-declare interface DatePickerProps {
-    date: Date | undefined;
-    setDate: (date: Date | undefined) => void;
-    className?: string;
-    placeholder?: string;
-}
-
-export { }
+import * as React from 'react';
+interface DatePickerProps {
+    date: Date | undefined;
+    setDate: (date: Date | undefined) => void;
+    className?: string;
+    placeholder?: string;
+}
+export declare function DatePicker({ date, setDate, className, placeholder }: DatePickerProps): React.JSX.Element;
+export {};

package/dist/components/date-picker/index.d.ts

@@ -0,0 +1 @@
+export * from './date-picker';

package/dist/components/feedback/feedback-reason.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+interface FeedbackReasonProps {
+    open: boolean;
+    onSubmit?: (reason: string) => void;
+    thankYouText?: string;
+    placeholder?: string;
+    maxLength?: number;
+}
+export declare function FeedbackReason({ open, onSubmit, thankYouText, placeholder, maxLength, }: FeedbackReasonProps): React.JSX.Element;
+export {};

package/dist/{feedback.d.ts → components/feedback/feedback.d.ts}

@@ -1,21 +1,17 @@
-import { default as default_2 } from 'react';
-
-export declare function Feedback({ feedback, onFeedback, textConfig, disabled, feedbackReasonLength, feedbackReasonPlaceholder, onFeedbackReasonSubmit, feedbackReasonThankYouText, }: FeedbackProps): default_2.JSX.Element;
-
-declare interface FeedbackProps {
-    feedback?: FeedbackResponse;
-    onFeedback?: (response: FeedbackResponse) => void;
-    textConfig?: {
-        positiveAnswerText?: string;
-        negativeAnswerText?: string;
-    };
-    disabled?: boolean;
-    feedbackReasonLength?: number;
-    feedbackReasonPlaceholder?: string;
-    onFeedbackReasonSubmit?: (reason: string) => void;
-    feedbackReasonThankYouText?: string;
-}
-
-export declare type FeedbackResponse = 'accept' | 'reject';
-
-export { }
+import { default as React } from 'react';
+export type FeedbackResponse = 'accept' | 'reject';
+interface FeedbackProps {
+    feedback?: FeedbackResponse;
+    onFeedback?: (response: FeedbackResponse) => void;
+    textConfig?: {
+        positiveAnswerText?: string;
+        negativeAnswerText?: string;
+    };
+    disabled?: boolean;
+    feedbackReasonLength?: number;
+    feedbackReasonPlaceholder?: string;
+    onFeedbackReasonSubmit?: (reason: string) => void;
+    feedbackReasonThankYouText?: string;
+}
+export declare function Feedback({ feedback, onFeedback, textConfig, disabled, feedbackReasonLength, feedbackReasonPlaceholder, onFeedbackReasonSubmit, feedbackReasonThankYouText, }: FeedbackProps): React.JSX.Element;
+export {};

package/dist/components/feedback/index.d.ts

@@ -0,0 +1 @@
+export { Feedback, type FeedbackResponse } from './feedback';