@brainfish-ai/components 0.35.19 → 0.36.0

package/dist/components/discoveries-created/index.d.ts

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

package/dist/components/editable-label/editable-label.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+export declare const EditableLabel: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+    placeholder?: string;
+    required?: boolean;
+} & React.RefAttributes<HTMLSpanElement>>;
+export default EditableLabel;

package/dist/components/editable-label/index.d.ts

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

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';

package/dist/components/file-upload/file-upload-status.d.ts

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+import { UploadState } from './types';
+export interface ProcessingStep {
+    id: string;
+    label: string;
+    status: 'completed' | 'current' | 'pending' | 'error';
+}
+interface FileUploadStatusProps {
+    uploads: UploadState[];
+    className?: string;
+    timeRemaining?: string;
+    onCancelUpload?: (e: React.MouseEvent<HTMLButtonElement>) => void;
+    steps?: ProcessingStep[];
+    title?: string;
+}
+export declare const FileUploadStatus: React.FC<FileUploadStatusProps>;
+export {};

package/dist/components/file-upload/file-upload.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { FileUploadProps } from './types';
+export declare function FileUpload({ onDropAccepted, onDropRejected, accept, maxSize, // 5MB
+maxFiles, multiple, className, disabled, title, description, supportsMessage, children, }: FileUploadProps): React.JSX.Element;

package/dist/components/file-upload/index.d.ts

@@ -0,0 +1,4 @@
+export * from './file-upload';
+export * from './file-upload-status';
+export * from './types';
+export * from './utils';

package/dist/components/file-upload/types.d.ts

@@ -0,0 +1,18 @@
+import { DropzoneOptions } from 'react-dropzone';
+import { ReactNode } from 'react';
+export interface UploadState {
+    id: string;
+    file: File;
+    status: 'pending' | 'uploading' | 'success' | 'error';
+    progress: number;
+    error?: string;
+    startTime?: number;
+    url?: string;
+}
+export interface FileUploadProps extends DropzoneOptions {
+    className?: string;
+    title?: string;
+    description?: ReactNode;
+    supportsMessage?: ReactNode;
+    children?: ReactNode;
+}

package/dist/components/file-upload/utils.d.ts

@@ -0,0 +1 @@
+export declare const formatFileSize: (bytes: number) => string;

package/dist/components/filter/components/CustomValueInput.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+interface CustomValueInputProps {
+    inputValue: string;
+    setInputValue: (value: string) => void;
+    customValuePlaceholder: string;
+    customValueButtonLabel: string;
+    onSubmit: () => void;
+    handleKeyDown: (e: React.KeyboardEvent<HTMLInputElement | HTMLButtonElement>, isInput: boolean) => void;
+}
+export declare const CustomValueInput: React.FC<CustomValueInputProps>;
+export {};

package/dist/components/filter/components/MultiSelectDropdown.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+import { FilterValue, FilterOption } from '../types';
+interface MultiSelectDropdownProps {
+    internalFilter: FilterValue;
+    valueOptions: FilterOption[];
+    onConfirm: (selectedValues: string[]) => void;
+    onClose: () => void;
+}
+export declare const MultiSelectDropdown: React.FC<MultiSelectDropdownProps>;
+export {};

package/dist/components/filter/components/SingleSelectDropdown.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+import { FilterOption } from '../types';
+interface SingleSelectDropdownProps {
+    valueOptions: FilterOption[];
+    isValueSelected: (valueId: string) => boolean;
+    onValueSelect: (valueId: string) => void;
+}
+export declare const SingleSelectDropdown: React.FC<SingleSelectDropdownProps>;
+export {};

package/dist/components/filter/filter.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+import { FilterProps } from './types';
+declare const Filter: React.ForwardRefExoticComponent<FilterProps & React.RefAttributes<{
+    focus: () => void;
+}>>;
+export { Filter };

package/dist/components/filter/filters.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+import { FilterOption, FilterRules, FilterValue } from './index';
+interface FiltersProps extends React.HTMLAttributes<HTMLDivElement> {
+    filters: FilterValue[];
+    onFilterChange: (filter: FilterValue) => void;
+    onFilterRemove: (filterId: string | number) => void;
+    onFilterAdd?: (filter: FilterValue) => void;
+    sourceOptions: FilterOption[];
+    rules: FilterRules;
+}
+declare const Filters: ({ filters, onFilterChange, onFilterRemove, onFilterAdd, sourceOptions, rules, className, }: FiltersProps) => React.JSX.Element;
+export { Filters };

package/dist/components/filter/hooks.d.ts

@@ -0,0 +1,9 @@
+import { FilterValue } from './types';
+export declare const useMultiSelectHelpers: (internalFilter: FilterValue, valueOptions: Array<{
+    id: string;
+    label: string;
+}>, selectPlaceholder: string) => {
+    getSelectedValues: () => string[];
+    isValueSelected: (valueId: string) => boolean;
+    getDisplayValue: () => string;
+};

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

@@ -0,0 +1,3 @@
+export * from './filter';
+export * from './filters';
+export * from './types';

package/dist/{filter.d.ts → components/filter/types.d.ts}

@@ -1,82 +1,59 @@
-import { default as default_2 } from 'react';
-
-export declare const Filter: default_2.ForwardRefExoticComponent<FilterProps & default_2.RefAttributes<{
-    focus: () => void;
-}>>;
-
-export declare interface FilterOption {
-    id: string;
-    label: string;
-}
-
-export declare interface FilterProps {
-    filter: FilterValue;
-    sourceOptions: FilterOption[];
-    rules: FilterRules;
-    onSourceChange?: (sourceId: string) => void;
-    onRemoveFilter: (id: string | number) => void;
-    onFilterChange: (filter: FilterValue) => void;
-    selectPlaceholder?: string;
-    customValuePlaceholder?: string;
-    customValueButtonLabel?: string;
-    sourceFirstMessage?: string;
-}
-
-/**
- * Filter rules for each source
- * How this works:
- * - You can define the rules for each source
- * - The rules are used to determine the available operators and value type
- * - The input type is used to determine the type of input displayed in when the dropdown is opened
- * - The getValueOptions function is used to determine the available options for the value
- * - multiSelect determines if multiple values can be selected for dropdown type
- *
- * @example
- * {
- *   'sourceId': {
- *     operators: [
- *       { id: 'is', label: 'is' },
- *       { id: 'is not', label: 'is not' },
- *     ],
- *     inputType: 'dropdown' | 'custom',
- *     multiSelect?: boolean,
- *     getValueOptions?: () => FilterOption[],
- *   },
- * }
- */
-export declare interface FilterRules {
-    [sourceId: string]: {
-        operators: FilterOption[];
-        inputType: 'dropdown' | 'custom';
-        multiSelect?: boolean;
-        getValueOptions?: () => FilterOption[];
-    };
-}
-
-export declare const Filters: ({ filters, onFilterChange, onFilterRemove, onFilterAdd, sourceOptions, rules, className, }: FiltersProps) => default_2.JSX.Element;
-
-declare interface FiltersProps extends default_2.HTMLAttributes<HTMLDivElement> {
-    filters: FilterValue[];
-    onFilterChange: (filter: FilterValue) => void;
-    onFilterRemove: (filterId: string | number) => void;
-    onFilterAdd?: (filter: FilterValue) => void;
-    sourceOptions: FilterOption[];
-    rules: FilterRules;
-}
-
-export declare interface FilterValue {
-    id: string | number;
-    source?: string;
-    operator?: Operator;
-    value?: string | string[];
-}
-
-export declare enum Operator {
-    IS = "is",
-    IS_NOT = "is not",
-    CONTAINS = "contains",
-    DOES_NOT_CONTAIN = "does not contain",
-    STARTS_WITH = "starts with"
-}
-
-export { }
+export interface FilterOption {
+    id: string;
+    label: string;
+}
+export declare enum Operator {
+    IS = "is",
+    IS_NOT = "is not",
+    CONTAINS = "contains",
+    DOES_NOT_CONTAIN = "does not contain",
+    STARTS_WITH = "starts with"
+}
+export interface FilterValue {
+    id: string | number;
+    source?: string;
+    operator?: Operator;
+    value?: string | string[];
+}
+/**
+ * Filter rules for each source
+ * How this works:
+ * - You can define the rules for each source
+ * - The rules are used to determine the available operators and value type
+ * - The input type is used to determine the type of input displayed in when the dropdown is opened
+ * - The getValueOptions function is used to determine the available options for the value
+ * - multiSelect determines if multiple values can be selected for dropdown type
+ *
+ * @example
+ * {
+ *   'sourceId': {
+ *     operators: [
+ *       { id: 'is', label: 'is' },
+ *       { id: 'is not', label: 'is not' },
+ *     ],
+ *     inputType: 'dropdown' | 'custom',
+ *     multiSelect?: boolean,
+ *     getValueOptions?: () => FilterOption[],
+ *   },
+ * }
+ */
+export interface FilterRules {
+    [sourceId: string]: {
+        operators: FilterOption[];
+        inputType: 'dropdown' | 'custom';
+        multiSelect?: boolean;
+        getValueOptions?: () => FilterOption[];
+    };
+}
+export interface FilterProps {
+    filter: FilterValue;
+    sourceOptions: FilterOption[];
+    rules: FilterRules;
+    onSourceChange?: (sourceId: string) => void;
+    onRemoveFilter: (id: string | number) => void;
+    onFilterChange: (filter: FilterValue) => void;
+    selectPlaceholder?: string;
+    customValuePlaceholder?: string;
+    customValueButtonLabel?: string;
+    sourceFirstMessage?: string;
+}

package/dist/components/font-picker/font-picker-item.d.ts

@@ -0,0 +1,13 @@
+import { FontOption } from './types';
+import * as React from 'react';
+export interface FontPickerItemProps {
+    font: FontOption;
+    isSelected: boolean;
+    onSelect: () => void;
+}
+/**
+ * Individual font item in the dropdown list
+ * Loads font on mount for preview using Intersection Observer
+ * Memoized to prevent unnecessary re-renders
+ */
+export declare const FontPickerItem: React.NamedExoticComponent<FontPickerItemProps>;

package/dist/components/font-picker/font-picker.d.ts

@@ -0,0 +1,44 @@
+import * as React from 'react';
+export interface FontPickerProps {
+    /** Currently selected font family */
+    value?: string;
+    /** Callback when font selection changes */
+    onChange?: (fontFamily: string) => void;
+    /** Google Fonts API key (required) */
+    apiKey: string;
+    /** Placeholder text when no font is selected */
+    placeholder?: string;
+    /** Text shown in search input */
+    searchPlaceholder?: string;
+    /** Text shown when no fonts match the search */
+    noResultsText?: string;
+    /** Text shown while fonts are loading */
+    loadingText?: string;
+    /** Whether the picker is disabled */
+    disabled?: boolean;
+    /** Additional CSS classes for the trigger button */
+    className?: string;
+    /** Width of the dropdown (defaults to trigger width) */
+    dropdownWidth?: number;
+    /** Maximum number of fonts to display (for performance) */
+    maxFonts?: number;
+    /** Callback when an error occurs fetching fonts */
+    onError?: (error: Error) => void;
+}
+/**
+ * FontPicker - A searchable dropdown for selecting Google Fonts
+ *
+ * @example
+ * ```tsx
+ * const [font, setFont] = useState('Inter');
+ *
+ * <FontPicker
+ *   apiKey="YOUR_API_KEY"
+ *   value={font}
+ *   onChange={setFont}
+ *   placeholder="Select a font"
+ * />
+ * ```
+ */
+export declare function FontPicker({ value, onChange, apiKey, placeholder, searchPlaceholder, noResultsText, loadingText, disabled, className, dropdownWidth, maxFonts, onError, }: FontPickerProps): React.JSX.Element;
+export default FontPicker;

package/dist/components/font-picker/font-utils.d.ts

@@ -0,0 +1,18 @@
+import { FontOption } from './types';
+/**
+ * Get cached fonts from localStorage
+ */
+export declare const getCachedFonts: () => FontOption[] | null;
+/**
+ * Save fonts to localStorage cache
+ */
+export declare const setCachedFonts: (fonts: FontOption[]) => void;
+/**
+ * Load a Google Font stylesheet dynamically
+ */
+export declare const loadFont: (fontFamily: string) => void;
+/**
+ * Clear the font cache from localStorage
+ * Useful for forcing a fresh fetch of fonts
+ */
+export declare const clearFontCache: () => void;

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

@@ -0,0 +1,5 @@
+export * from './font-picker';
+export * from './font-picker-item';
+export * from './font-utils';
+export * from './use-font-options';
+export * from './types';

package/dist/components/font-picker/types.d.ts

@@ -0,0 +1,6 @@
+export interface FontOption {
+    value: string;
+    label: string;
+    category?: string;
+    variants?: string[];
+}

package/dist/components/font-picker/use-font-options.d.ts

@@ -0,0 +1,17 @@
+import { FontOption } from './types';
+import { loadFont } from './font-utils';
+export interface UseFontOptionsProps {
+    apiKey: string;
+    maxFonts?: number;
+    onError?: (error: Error) => void;
+}
+export interface UseFontOptionsReturn {
+    fonts: FontOption[];
+    isLoading: boolean;
+    loadFont: typeof loadFont;
+}
+/**
+ * Hook to fetch and manage Google Fonts options
+ * Handles caching, loading state, and font stylesheet loading
+ */
+export declare function useFontOptions({ apiKey, maxFonts, onError }: UseFontOptionsProps): UseFontOptionsReturn;

package/dist/components/generating-star/generating-star.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+import { VariantProps } from 'class-variance-authority';
+declare const generatingStarVariants: (props?: ({
+    variant?: "disabled" | "default" | "gradient" | null | undefined;
+    loading?: boolean | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface GeneratingStarProps extends React.HTMLAttributes<SVGElement>, VariantProps<typeof generatingStarVariants> {
+}
+declare function GeneratingStar({ loading, variant, className, ...props }: GeneratingStarProps): React.JSX.Element;
+export { GeneratingStar, generatingStarVariants };

package/dist/components/generating-star/index.d.ts

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

package/dist/components/input-with-tags/index.d.ts

@@ -0,0 +1 @@
+export * from './input-with-tags';

package/dist/{input-with-tags.d.ts → components/input-with-tags/input-with-tags.d.ts}

@@ -1,31 +1,26 @@
-import * as React_2 from 'react';
-
-export declare function InputWithTags({ title, placeholder, tags, value: controlledValue, defaultValue, onChange, onTagClick, singleValue, className, inputClassName, tagsClassName, disabled, name, id, required, maxLength, minLength, rows, }: InputWithTagsProps): React_2.JSX.Element;
-
-export declare interface InputWithTagsProps {
-    title: string;
-    placeholder?: string;
-    tags: Tag[];
-    value?: string;
-    defaultValue?: string;
-    onChange?: (value: string) => void;
-    onTagClick?: (tag: Tag) => void;
-    singleValue?: boolean;
-    className?: string;
-    inputClassName?: string;
-    tagsClassName?: string;
-    disabled?: boolean;
-    name?: string;
-    id?: string;
-    required?: boolean;
-    maxLength?: number;
-    minLength?: number;
-    rows?: number;
-}
-
-export declare interface Tag {
-    label: string;
-    value: string;
-}
-
-export { }
+import * as React from 'react';
+export interface Tag {
+    label: string;
+    value: string;
+}
+export interface InputWithTagsProps {
+    title: string;
+    placeholder?: string;
+    tags: Tag[];
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    onTagClick?: (tag: Tag) => void;
+    singleValue?: boolean;
+    className?: string;
+    inputClassName?: string;
+    tagsClassName?: string;
+    disabled?: boolean;
+    name?: string;
+    id?: string;
+    required?: boolean;
+    maxLength?: number;
+    minLength?: number;
+    rows?: number;
+}
+export declare function InputWithTags({ title, placeholder, tags, value: controlledValue, defaultValue, onChange, onTagClick, singleValue, className, inputClassName, tagsClassName, disabled, name, id, required, maxLength, minLength, rows, }: InputWithTagsProps): React.JSX.Element;

package/dist/components/logo/ai-logo.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+export type AILogoVariant = 'dark' | 'light' | 'yellowfin' | 'monochrome';
+type AILogoPathsProps = {
+    variant: AILogoVariant;
+    gradientId: string;
+};
+export declare function AILogoPaths({ variant, gradientId }: AILogoPathsProps): React.JSX.Element;
+export interface AILogoProps extends React.SVGProps<SVGSVGElement> {
+    variant: AILogoVariant;
+}
+export declare const AILogo: React.ForwardRefExoticComponent<Omit<AILogoProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export {};

package/dist/components/logo/chat-logo.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+interface ChatLogoProps {
+    size?: number | string;
+    className?: string;
+    color?: string;
+}
+export declare function ChatLogo({ size, className, color }: ChatLogoProps): React.JSX.Element;
+export {};

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

@@ -0,0 +1,3 @@
+export * from './logo';
+export * from './chat-logo';
+export * from './ai-logo';

package/dist/components/logo/logo.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+export type LogoVariant = 'mark' | 'text' | 'full';
+export type LogoColor = 'default' | 'outline' | 'fill' | 'fill-light';
+export interface LogoProps extends React.SVGProps<SVGSVGElement> {
+    variant: LogoVariant;
+    color?: LogoColor;
+}
+export declare const Logo: React.ForwardRefExoticComponent<Omit<LogoProps, "ref"> & React.RefAttributes<SVGSVGElement>>;

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

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

package/dist/components/love/love.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+interface LoveProps extends React.HTMLAttributes<HTMLDivElement> {
+    className?: string;
+    doAnimation?: boolean;
+}
+export declare function Love({ className, children, doAnimation, ...props }: LoveProps): React.JSX.Element;
+export {};

package/dist/components/markdown/CodeBlock.d.ts

@@ -0,0 +1,7 @@
+import { FC } from 'react';
+interface Props {
+    language: string;
+    value: string;
+}
+export declare const CodeBlock: FC<Props>;
+export {};

package/dist/components/markdown/FormattedMessage.d.ts

@@ -0,0 +1,14 @@
+import { FC } from 'react';
+import { RedirectRule } from '../chat-search/types';
+type Message = {
+    content: string;
+    uncertaintyFallbackText?: Record<string, string>;
+};
+export interface Props {
+    message: Message;
+    isStreaming?: boolean;
+    redirectRules?: RedirectRule[];
+    contentTypeEndpoint?: string;
+}
+export declare const FormattedMessage: FC<Props>;
+export {};

package/dist/components/markdown/Frame.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+type Props = {
+    src?: string;
+    border?: boolean;
+    width?: string;
+    height?: string;
+    title?: string;
+};
+declare const Frame: React.ForwardRefExoticComponent<Props & React.RefAttributes<HTMLIFrameElement>>;
+export default Frame;

package/dist/components/markdown/MemoizedReactMarkdown.d.ts

@@ -0,0 +1,6 @@
+import { FC } from 'react';
+import { Options } from 'react-markdown';
+export interface MemoizedReactMarkdownProps extends Options {
+    isStreaming?: boolean;
+}
+export declare const MemoizedReactMarkdown: FC<MemoizedReactMarkdownProps>;

package/dist/components/markdown/MermaidDiagram.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+interface MermaidDiagramProps {
+    content: string;
+}
+export declare const MermaidDiagram: React.FC<MermaidDiagramProps>;
+export default MermaidDiagram;

package/dist/components/markdown/SmartImage.d.ts

@@ -0,0 +1,5 @@
+import { FC } from 'react';
+export declare const SmartImage: FC<{
+    src: string;
+    alt?: string;
+}>;