@anvia/react-ui 0.2.0 → 0.4.0

package/dist/chunk-KO36TK2O.js

@@ -0,0 +1,1549 @@
+import {
+  Message
+} from "./chunk-FZANAMWH.js";
+import {
+  Attachment
+} from "./chunk-32QFNRXR.js";
+import {
+  composeRefs,
+  renderPrimitive
+} from "./chunk-T3ZFZ3NP.js";
+import {
+  InternalAttachmentProvider,
+  InternalComposerProvider,
+  InternalMessageProvider,
+  InternalThreadProvider,
+  useChatContext,
+  useComposer,
+  useThread
+} from "./chunk-BCCU3VT5.js";
+
+// src/chat/composer.tsx
+import { mergeAttributes } from "@tiptap/core";
+import Document from "@tiptap/extension-document";
+import HardBreak from "@tiptap/extension-hard-break";
+import Mention from "@tiptap/extension-mention";
+import Paragraph from "@tiptap/extension-paragraph";
+import Placeholder from "@tiptap/extension-placeholder";
+import Text from "@tiptap/extension-text";
+import { PluginKey } from "@tiptap/pm/state";
+import { EditorContent, useEditor } from "@tiptap/react";
+import {
+  forwardRef,
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var ComposerRoot = forwardRef(function ComposerRoot2({
+  attachments: attachmentsProp,
+  defaultAttachments,
+  defaultEntities,
+  defaultInput = "",
+  defaultQuote,
+  entities: entitiesProp,
+  input: inputProp,
+  onAttachmentsChange,
+  onEntitiesChange,
+  onInputChange,
+  onQuoteChange,
+  quote: quoteProp,
+  submitMessage,
+  triggers: triggersProp,
+  onSubmit,
+  ...props
+}, ref) {
+  const chat = useChatContext();
+  const [uncontrolledInput, setUncontrolledInput] = useState(defaultInput);
+  const [uncontrolledAttachments, setUncontrolledAttachments] = useState(() => [
+    ...defaultAttachments ?? []
+  ]);
+  const [uncontrolledEntities, setUncontrolledEntities] = useState(() => [
+    ...defaultEntities ?? []
+  ]);
+  const [uncontrolledQuote, setUncontrolledQuote] = useState(
+    defaultQuote
+  );
+  const [activeTrigger, setActiveTriggerState] = useState();
+  const input = inputProp ?? uncontrolledInput;
+  const attachments = attachmentsProp ?? uncontrolledAttachments;
+  const entities = entitiesProp ?? uncontrolledEntities;
+  const triggers = triggersProp ?? EMPTY_COMPOSER_TRIGGERS;
+  const rawQuote = quoteProp ?? uncontrolledQuote;
+  const rawQuoteMessageId = rawQuote?.messageId;
+  const rawQuoteText = rawQuote?.text;
+  const quote = useMemo(
+    () => rawQuoteMessageId === void 0 || rawQuoteText === void 0 ? void 0 : { messageId: rawQuoteMessageId, text: rawQuoteText },
+    [rawQuoteMessageId, rawQuoteText]
+  );
+  const attachmentsRef = useRef(attachments);
+  attachmentsRef.current = attachments;
+  const entitiesRef = useRef(entities);
+  entitiesRef.current = entities;
+  const inputControlled = inputProp !== void 0;
+  const attachmentsControlled = attachmentsProp !== void 0;
+  const entitiesControlled = entitiesProp !== void 0;
+  const quoteControlled = quoteProp !== void 0;
+  const hasMessageContent = input.trim().length > 0 || attachments.length > 0 || entities.length > 0 || quote !== void 0;
+  const canSubmit = hasMessageContent && chat.status !== "streaming";
+  const canStop = chat.status === "streaming";
+  const setInput = useCallback(
+    (nextInput) => {
+      if (!inputControlled) {
+        setUncontrolledInput(nextInput);
+      }
+      onInputChange?.(nextInput);
+    },
+    [inputControlled, onInputChange]
+  );
+  const setAttachments = useCallback(
+    (update) => {
+      const nextAttachments = typeof update === "function" ? update(attachmentsRef.current) : update;
+      attachmentsRef.current = nextAttachments;
+      if (!attachmentsControlled) {
+        setUncontrolledAttachments(nextAttachments);
+      }
+      onAttachmentsChange?.(nextAttachments);
+    },
+    [attachmentsControlled, onAttachmentsChange]
+  );
+  const setEntities = useCallback(
+    (update) => {
+      const nextEntities = typeof update === "function" ? update(entitiesRef.current) : update;
+      entitiesRef.current = nextEntities;
+      if (!entitiesControlled) {
+        setUncontrolledEntities(nextEntities);
+      }
+      onEntitiesChange?.(nextEntities);
+    },
+    [entitiesControlled, onEntitiesChange]
+  );
+  const setQuote = useCallback(
+    (nextQuote) => {
+      const normalizedQuote = normalizeQuote(nextQuote);
+      if (!quoteControlled) {
+        setUncontrolledQuote(normalizedQuote);
+      }
+      onQuoteChange?.(normalizedQuote);
+    },
+    [onQuoteChange, quoteControlled]
+  );
+  const addAttachment = useCallback(
+    async (attachment) => {
+      const normalized = isFileAttachmentInput(attachment) ? await attachmentFromFile(attachment) : createAttachment(attachment);
+      setAttachments((current) => [...current, normalized]);
+    },
+    [setAttachments]
+  );
+  const removeAttachment = useCallback(
+    (id) => {
+      setAttachments((current) => current.filter((attachment) => attachment.id !== id));
+    },
+    [setAttachments]
+  );
+  const clearAttachments = useCallback(() => {
+    setAttachments([]);
+  }, [setAttachments]);
+  const clearQuote = useCallback(() => {
+    setQuote(void 0);
+  }, [setQuote]);
+  const clear = useCallback(() => {
+    setInput("");
+    setAttachments([]);
+    setEntities([]);
+    setActiveTriggerState(void 0);
+    clearQuote();
+  }, [clearQuote, setAttachments, setEntities, setInput]);
+  const submit = useCallback(async () => {
+    const prompt = input;
+    if (prompt.trim().length === 0 && attachments.length === 0 && entities.length === 0 && quote === void 0 || chat.status === "streaming") {
+      return;
+    }
+    if (submitMessage !== void 0) {
+      await submitMessage({
+        input: prompt,
+        attachments,
+        entities,
+        chat,
+        quote,
+        clear
+      });
+      return;
+    }
+    const submittedText = quote === void 0 ? prompt : promptWithQuote(prompt, quote);
+    const metadata = composerSubmitMetadata(quote, entities);
+    if (attachments.length === 0) {
+      if (metadata === void 0) {
+        await chat.sendMessage(prompt);
+      } else {
+        await chat.sendMessage({
+          text: submittedText,
+          metadata
+        });
+      }
+    } else {
+      await chat.sendMessage({
+        text: submittedText,
+        attachments,
+        ...metadata === void 0 ? {} : { metadata }
+      });
+    }
+    clear();
+  }, [attachments, chat, clear, entities, input, quote, submitMessage]);
+  const setActiveTrigger = useCallback((update) => {
+    setActiveTriggerState(update);
+  }, []);
+  const value = useMemo(
+    () => ({
+      input,
+      setInput,
+      attachments,
+      setAttachments,
+      addAttachment,
+      removeAttachment,
+      clearAttachments,
+      entities,
+      setEntities,
+      quote,
+      setQuote,
+      clearQuote,
+      triggers,
+      activeTrigger,
+      setActiveTrigger,
+      submit,
+      stop: chat.stop,
+      status: chat.status,
+      canSubmit,
+      canStop
+    }),
+    [
+      addAttachment,
+      attachments,
+      activeTrigger,
+      canStop,
+      canSubmit,
+      chat.status,
+      chat.stop,
+      clearAttachments,
+      clearQuote,
+      entities,
+      input,
+      quote,
+      removeAttachment,
+      setAttachments,
+      setActiveTrigger,
+      setEntities,
+      setInput,
+      setQuote,
+      submit,
+      triggers
+    ]
+  );
+  const handleSubmit = useCallback(
+    (event) => {
+      onSubmit?.(event);
+      if (event.defaultPrevented) {
+        return;
+      }
+      event.preventDefault();
+      void submit();
+    },
+    [onSubmit, submit]
+  );
+  return /* @__PURE__ */ jsx(InternalComposerProvider, { value, children: renderPrimitive(
+    "form",
+    {
+      ...props,
+      onSubmit: handleSubmit,
+      "data-anvia-composer": "",
+      "data-state": chat.status
+    },
+    ref
+  ) });
+});
+var ComposerQuotePreview = forwardRef(
+  function ComposerQuotePreview2({ children, ...props }, ref) {
+    const composer = useComposer();
+    const quote = composer.quote;
+    if (quote === void 0) {
+      return null;
+    }
+    const renderedChildren = typeof children === "function" ? children(quote) : children ?? quote.text;
+    return renderPrimitive(
+      "blockquote",
+      {
+        ...props,
+        children: renderedChildren,
+        "data-anvia-composer-quote": "",
+        "data-message-id": quote.messageId
+      },
+      ref
+    );
+  }
+);
+var ComposerClearQuote = forwardRef(
+  function ComposerClearQuote2({ onClick, ...props }, ref) {
+    const composer = useComposer();
+    const disabled = props.disabled ?? composer.quote === void 0;
+    const handleClick = useCallback(
+      (event) => {
+        onClick?.(event);
+        if (event.defaultPrevented || disabled) {
+          return;
+        }
+        composer.clearQuote();
+      },
+      [composer, disabled, onClick]
+    );
+    return renderPrimitive(
+      "button",
+      {
+        ...props,
+        children: props.children ?? "Clear quote",
+        disabled,
+        onClick: handleClick,
+        type: props.type ?? "button",
+        "data-anvia-clear-quote": "",
+        "data-state": disabled ? "disabled" : "enabled"
+      },
+      ref
+    );
+  }
+);
+var ComposerInput = forwardRef(function ComposerInput2({
+  autoResize = true,
+  disabled,
+  maxRows: maxRowsProp,
+  minRows: minRowsProp,
+  onKeyDown,
+  placeholder,
+  style,
+  ...props
+}, ref) {
+  const composer = useComposer();
+  const composerRef = useRef(composer);
+  composerRef.current = composer;
+  const editorReadyRef = useRef(false);
+  const syncingFromEditorRef = useRef(false);
+  const triggers = composer.triggers;
+  const minRows = normalizeRows(minRowsProp ?? 1, 1);
+  const maxRows = normalizeRows(maxRowsProp ?? 6, minRows);
+  const extensions = useMemo(
+    () => composerInputExtensions({
+      composerRef,
+      placeholder,
+      triggers
+    }),
+    [placeholder, triggers]
+  );
+  const editor = useEditor(
+    {
+      extensions,
+      content: plainTextToComposerContent(composer.input),
+      editable: composer.status !== "streaming",
+      editorProps: {
+        attributes: {
+          "aria-label": props["aria-label"] ?? "Message",
+          "aria-multiline": "true",
+          "data-anvia-composer-editor": "",
+          role: "textbox"
+        }
+      },
+      onUpdate: ({ editor: updatedEditor }) => {
+        if (!editorReadyRef.current) {
+          return;
+        }
+        const snapshot = composerSnapshotFromEditor(
+          updatedEditor,
+          composerRef.current.entities,
+          composerRef.current.triggers
+        );
+        syncingFromEditorRef.current = true;
+        composerRef.current.setInput(snapshot.input);
+        composerRef.current.setEntities(snapshot.entities);
+      }
+    },
+    [extensions]
+  );
+  const ariaDisabled = props["aria-disabled"] === true || props["aria-disabled"] === "true";
+  const composerDisabled = disabled === true || ariaDisabled || composer.status === "streaming";
+  const inputStyle = useMemo(() => {
+    if (!autoResize) {
+      return style;
+    }
+    const rowsStyle = {
+      ["--anvia-composer-min-rows"]: minRows,
+      ["--anvia-composer-max-rows"]: maxRows
+    };
+    return style === void 0 ? rowsStyle : { ...rowsStyle, ...style };
+  }, [autoResize, maxRows, minRows, style]);
+  const handleKeyDown = useCallback(
+    (event) => {
+      onKeyDown?.(event);
+      if (event.defaultPrevented || event.key !== "Enter" || event.shiftKey || event.nativeEvent.isComposing) {
+        return;
+      }
+      event.preventDefault();
+      void composerRef.current.submit();
+    },
+    [onKeyDown]
+  );
+  useEffect(() => {
+    if (editor === null) {
+      return;
+    }
+    editor.setEditable(!composerDisabled, false);
+  }, [composerDisabled, editor]);
+  useEffect(() => {
+    if (editor === null) {
+      return;
+    }
+    const handleKeyDown2 = (event) => {
+      if (submitComposerFromEditorKeyDown(event, composerRef)) {
+        event.stopPropagation();
+      }
+    };
+    editor.view.dom.addEventListener("keydown", handleKeyDown2, true);
+    return () => {
+      editor.view.dom.removeEventListener("keydown", handleKeyDown2, true);
+    };
+  }, [editor]);
+  useEffect(() => {
+    if (editor === null) {
+      return;
+    }
+    editor.commands.setContent(plainTextToComposerContent(composerRef.current.input), {
+      emitUpdate: false
+    });
+    editorReadyRef.current = true;
+    return () => {
+      editorReadyRef.current = false;
+    };
+  }, [editor]);
+  useEffect(() => {
+    if (editor === null || !editorReadyRef.current) {
+      return;
+    }
+    if (syncingFromEditorRef.current) {
+      syncingFromEditorRef.current = false;
+      return;
+    }
+    const snapshot = composerSnapshotFromEditor(editor, composer.entities, composer.triggers);
+    if (snapshot.input === composer.input) {
+      return;
+    }
+    editor.commands.setContent(plainTextToComposerContent(composer.input), {
+      emitUpdate: false
+    });
+  }, [composer, editor]);
+  return renderPrimitive(
+    "div",
+    {
+      ...props,
+      children: /* @__PURE__ */ jsx(EditorContent, { editor }),
+      "aria-disabled": composerDisabled ? true : props["aria-disabled"],
+      "data-anvia-composer-input": "",
+      "data-state": composerDisabled ? "disabled" : "enabled",
+      "data-auto-resize": autoResize ? "" : void 0,
+      onKeyDown: handleKeyDown,
+      style: inputStyle
+    },
+    ref
+  );
+});
+var ComposerTextareaInput = forwardRef(
+  function ComposerTextareaInput2({
+    autoResize = true,
+    maxRows: maxRowsProp,
+    minRows: minRowsProp,
+    onChange,
+    onKeyDown,
+    rows,
+    ...props
+  }, ref) {
+    const composer = useComposer();
+    const inputRef = useRef(null);
+    const wasAutoResizeRef = useRef(autoResize);
+    const composedInputRef = useMemo(() => composeRefs(inputRef, ref), [ref]);
+    const minRows = normalizeRows(minRowsProp ?? rows ?? 1, 1);
+    const maxRows = normalizeRows(maxRowsProp ?? 6, minRows);
+    useEffect(() => {
+      const wasAutoResize = wasAutoResizeRef.current;
+      wasAutoResizeRef.current = autoResize;
+      if (!autoResize) {
+        if (wasAutoResize) {
+          resetComposerInputSize(inputRef.current);
+        }
+        return;
+      }
+      resizeComposerInput(inputRef.current, { maxRows, minRows });
+    });
+    const handleChange = useCallback(
+      (event) => {
+        onChange?.(event);
+        if (!event.defaultPrevented) {
+          composer.setInput(event.currentTarget.value);
+          composer.setEntities([]);
+          if (autoResize) {
+            resizeComposerInput(event.currentTarget, { maxRows, minRows });
+          }
+        }
+      },
+      [autoResize, composer, maxRows, minRows, onChange]
+    );
+    const handleKeyDown = useCallback(
+      (event) => {
+        onKeyDown?.(event);
+        if (event.defaultPrevented || event.key !== "Enter" || event.shiftKey || event.nativeEvent.isComposing) {
+          return;
+        }
+        event.preventDefault();
+        void composer.submit();
+      },
+      [composer, onKeyDown]
+    );
+    return renderPrimitive(
+      "textarea",
+      {
+        ...props,
+        "aria-label": props["aria-label"] ?? "Message",
+        disabled: props.disabled ?? composer.status === "streaming",
+        onChange: handleChange,
+        onKeyDown: handleKeyDown,
+        rows: autoResize ? minRows : rows,
+        value: composer.input,
+        "data-anvia-composer-input": "",
+        "data-anvia-composer-textarea-input": ""
+      },
+      composedInputRef
+    );
+  }
+);
+var COMPOSER_ENTITY_NODE = "composerEntity";
+var EMPTY_COMPOSER_TRIGGERS = [];
+var ComposerEntityExtension = Mention.extend({
+  name: COMPOSER_ENTITY_NODE,
+  addAttributes() {
+    return {
+      id: {
+        default: null,
+        parseHTML: (element) => element.getAttribute("data-id"),
+        renderHTML: (attributes) => attributes.id === void 0 || attributes.id === null ? {} : { "data-id": String(attributes.id) }
+      },
+      label: {
+        default: null,
+        parseHTML: (element) => element.getAttribute("data-label"),
+        renderHTML: (attributes) => attributes.label === void 0 || attributes.label === null ? {} : { "data-label": String(attributes.label) }
+      },
+      mentionSuggestionChar: {
+        default: "@",
+        parseHTML: (element) => element.getAttribute("data-mention-suggestion-char"),
+        renderHTML: (attributes) => ({
+          "data-mention-suggestion-char": attributes.mentionSuggestionChar
+        })
+      },
+      triggerId: {
+        default: null,
+        parseHTML: (element) => element.getAttribute("data-trigger-id"),
+        renderHTML: (attributes) => attributes.triggerId === void 0 || attributes.triggerId === null ? {} : { "data-trigger-id": String(attributes.triggerId) }
+      },
+      text: {
+        default: null,
+        parseHTML: (element) => element.getAttribute("data-text"),
+        renderHTML: (attributes) => attributes.text === void 0 || attributes.text === null ? {} : { "data-text": String(attributes.text) }
+      },
+      data: {
+        default: null,
+        parseHTML: (element) => dataFromAttribute(element.getAttribute("data-entity-data")),
+        renderHTML: (attributes) => attributes.data === void 0 || attributes.data === null ? {} : { "data-entity-data": JSON.stringify(attributes.data) }
+      }
+    };
+  }
+});
+function composerInputExtensions({
+  composerRef,
+  placeholder,
+  triggers
+}) {
+  return [
+    Document,
+    Paragraph,
+    Text,
+    HardBreak,
+    Placeholder.configure(placeholder === void 0 ? {} : { placeholder }),
+    ComposerEntityExtension.configure({
+      HTMLAttributes: {
+        "data-anvia-composer-entity": ""
+      },
+      deleteTriggerWithBackspace: true,
+      renderText: ({ node }) => composerEntityText(node.attrs),
+      renderHTML: ({ node, options }) => [
+        "span",
+        mergeAttributes(options.HTMLAttributes, {
+          "data-anvia-composer-entity": ""
+        }),
+        composerEntityText(node.attrs)
+      ],
+      suggestions: triggers.map((trigger) => composerSuggestion(trigger, composerRef))
+    })
+  ];
+}
+function submitComposerFromEditorKeyDown(event, composerRef) {
+  if (event.defaultPrevented || event.key !== "Enter" || event.shiftKey || event.isComposing || composerRef.current.activeTrigger !== void 0) {
+    return false;
+  }
+  event.preventDefault();
+  void composerRef.current.submit();
+  return true;
+}
+function composerSuggestion(trigger, composerRef) {
+  const pluginKey = new PluginKey(`anvia-composer-trigger-${trigger.id}`);
+  return {
+    pluginKey,
+    char: trigger.char,
+    ...trigger.allowSpaces === void 0 ? {} : { allowSpaces: trigger.allowSpaces },
+    ...trigger.allowedPrefixes === void 0 ? {} : { allowedPrefixes: trigger.allowedPrefixes },
+    ...trigger.startOfLine === void 0 ? {} : { startOfLine: trigger.startOfLine },
+    ...trigger.minQueryLength === void 0 ? {} : { minQueryLength: trigger.minQueryLength },
+    items: ({ query, signal }) => resolveTriggerItems(trigger, query, composerRef.current, signal),
+    command: ({
+      editor,
+      range,
+      props
+    }) => {
+      const nodeAfter = editor.view.state.selection.$to.nodeAfter;
+      const overrideSpace = nodeAfter?.text?.startsWith(" ");
+      const insertRange = {
+        from: range.from,
+        to: overrideSpace ? range.to + 1 : range.to
+      };
+      editor.chain().focus().insertContentAt(insertRange, [
+        {
+          type: COMPOSER_ENTITY_NODE,
+          attrs: props
+        },
+        {
+          type: "text",
+          text: " "
+        }
+      ]).run();
+      editor.view.dom.ownerDocument.defaultView?.getSelection()?.collapseToEnd();
+      composerRef.current.setActiveTrigger(void 0);
+    },
+    render: () => ({
+      onStart: (props) => {
+        updateComposerTriggerState(trigger, props, composerRef);
+      },
+      onUpdate: (props) => {
+        updateComposerTriggerState(trigger, props, composerRef);
+      },
+      onExit: () => {
+        composerRef.current.setActiveTrigger(
+          (current) => current?.trigger.id === trigger.id ? void 0 : current
+        );
+      },
+      onKeyDown: (props) => handleComposerTriggerKeyDown(trigger, props, composerRef)
+    })
+  };
+}
+function resolveTriggerItems(trigger, query, composer, signal) {
+  if (Array.isArray(trigger.items)) {
+    const normalizedQuery = query.toLowerCase();
+    return trigger.items.filter((item) => item.label.toLowerCase().includes(normalizedQuery));
+  }
+  return trigger.items({
+    trigger,
+    query,
+    input: composer.input,
+    entities: composer.entities,
+    signal
+  });
+}
+function updateComposerTriggerState(trigger, props, composerRef) {
+  const current = composerRef.current.activeTrigger;
+  const selectedIndex = current?.trigger.id === trigger.id ? clampIndex(current.selectedIndex, props.items.length) : 0;
+  const rect = rectFromSuggestion(props);
+  composerRef.current.setActiveTrigger({
+    trigger,
+    query: props.query,
+    items: props.items,
+    loading: props.loading,
+    selectedIndex,
+    ...rect === void 0 ? {} : { rect },
+    selectItem: (item) => {
+      if (item.disabled) {
+        return;
+      }
+      props.command(triggerItemToEntityAttrs(trigger, item));
+    },
+    setSelectedIndex: (index) => {
+      composerRef.current.setActiveTrigger(
+        (active) => active?.trigger.id === trigger.id ? { ...active, selectedIndex: clampIndex(index, active.items.length) } : active
+      );
+    }
+  });
+}
+function handleComposerTriggerKeyDown(trigger, { event }, composerRef) {
+  const activeTrigger = composerRef.current.activeTrigger;
+  if (activeTrigger?.trigger.id !== trigger.id) {
+    return false;
+  }
+  if (event.key === "ArrowDown") {
+    event.preventDefault();
+    activeTrigger.setSelectedIndex(activeTrigger.selectedIndex + 1);
+    return true;
+  }
+  if (event.key === "ArrowUp") {
+    event.preventDefault();
+    activeTrigger.setSelectedIndex(activeTrigger.selectedIndex - 1);
+    return true;
+  }
+  if (event.key === "Enter" || event.key === "Tab") {
+    event.preventDefault();
+    const item = activeTrigger.items[activeTrigger.selectedIndex];
+    if (item !== void 0) {
+      activeTrigger.selectItem(item);
+    }
+    return true;
+  }
+  if (event.key === "Escape") {
+    composerRef.current.setActiveTrigger(void 0);
+    return false;
+  }
+  return false;
+}
+function triggerItemToEntityAttrs(trigger, item) {
+  return {
+    id: item.id,
+    label: item.label,
+    mentionSuggestionChar: trigger.char,
+    triggerId: trigger.id,
+    text: triggerItemText(trigger, item),
+    data: item.data
+  };
+}
+function triggerItemText(trigger, item) {
+  return item.text ?? `${trigger.char}${item.label}`;
+}
+function rectFromSuggestion(props) {
+  const rect = props.clientRect?.();
+  if (rect === void 0 || rect === null) {
+    return void 0;
+  }
+  return {
+    top: rect.top,
+    right: rect.right,
+    bottom: rect.bottom,
+    left: rect.left,
+    width: rect.width,
+    height: rect.height
+  };
+}
+function clampIndex(index, length) {
+  if (length <= 0) {
+    return 0;
+  }
+  return (index + length) % length;
+}
+function plainTextToComposerContent(input) {
+  const lines = input.length === 0 ? [""] : input.split(/\r?\n/);
+  return {
+    type: "doc",
+    content: lines.map((line) => ({
+      type: "paragraph",
+      ...line.length === 0 ? {} : {
+        content: [
+          {
+            type: "text",
+            text: line
+          }
+        ]
+      }
+    }))
+  };
+}
+function composerSnapshotFromEditor(editor, previousEntities, triggers) {
+  return composerSnapshotFromContent(editor.getJSON(), previousEntities, triggers);
+}
+function composerSnapshotFromContent(content, previousEntities, triggers) {
+  const entities = [];
+  let input = "";
+  let blockIndex = 0;
+  const appendNode = (node) => {
+    if (node.type === "doc") {
+      for (const child of node.content ?? []) {
+        appendNode(child);
+      }
+      return;
+    }
+    if (node.type === "paragraph") {
+      if (blockIndex > 0) {
+        input += "\n";
+      }
+      blockIndex += 1;
+      for (const child of node.content ?? []) {
+        appendNode(child);
+      }
+      return;
+    }
+    if (node.type === "text") {
+      input += node.text ?? "";
+      return;
+    }
+    if (node.type === "hardBreak") {
+      input += "\n";
+      return;
+    }
+    if (node.type === COMPOSER_ENTITY_NODE) {
+      const attrs = node.attrs;
+      const entity = composerEntityFromAttrs(attrs, input.length, previousEntities, triggers);
+      input += entity.text;
+      entities.push(entity);
+      return;
+    }
+    for (const child of node.content ?? []) {
+      appendNode(child);
+    }
+  };
+  appendNode(content);
+  return { input, entities };
+}
+function composerEntityFromAttrs(attrs, from, previousEntities, triggers) {
+  const id = stringAttr(attrs?.id) ?? "";
+  const trigger = stringAttr(attrs?.mentionSuggestionChar) ?? "@";
+  const triggerId = stringAttr(attrs?.triggerId) ?? triggers.find((candidate) => candidate.char === trigger)?.id ?? trigger;
+  const label = stringAttr(attrs?.label) ?? id;
+  const text = composerEntityText(attrs);
+  const previous = previousEntities.find(
+    (entity) => entity.id === id && entity.triggerId === triggerId && entity.trigger === trigger
+  );
+  const data = attrs?.data ?? previous?.data;
+  return {
+    id,
+    triggerId,
+    trigger,
+    label,
+    text,
+    range: {
+      from,
+      to: from + text.length
+    },
+    ...data === void 0 ? {} : { data }
+  };
+}
+function composerEntityText(attrs) {
+  const text = stringAttr(attrs?.text);
+  if (text !== void 0) {
+    return text;
+  }
+  const trigger = stringAttr(attrs?.mentionSuggestionChar) ?? "@";
+  return `${trigger}${stringAttr(attrs?.label) ?? stringAttr(attrs?.id) ?? ""}`;
+}
+function stringAttr(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function dataFromAttribute(value) {
+  if (value === null) {
+    return null;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+function resizeComposerInput(input, { maxRows, minRows }) {
+  if (input === null) {
+    return;
+  }
+  const style = getComputedStyle(input);
+  const lineHeight = lineHeightFromStyle(style);
+  const paddingHeight = pixelValue(style.paddingTop) + pixelValue(style.paddingBottom);
+  const borderHeight = pixelValue(style.borderTopWidth) + pixelValue(style.borderBottomWidth);
+  const minContentHeight = lineHeight * minRows;
+  const maxContentHeight = Math.max(minContentHeight, lineHeight * maxRows);
+  input.style.height = "auto";
+  const scrollContentHeight = Math.max(input.scrollHeight - paddingHeight, 0);
+  const contentHeight = clamp(scrollContentHeight, minContentHeight, maxContentHeight);
+  const nextHeight = style.boxSizing === "border-box" ? contentHeight + paddingHeight + borderHeight : contentHeight;
+  input.style.height = `${Math.ceil(nextHeight)}px`;
+  input.style.overflowY = scrollContentHeight > maxContentHeight ? "auto" : "hidden";
+}
+function resetComposerInputSize(input) {
+  if (input === null) {
+    return;
+  }
+  input.style.height = "";
+  input.style.overflowY = "";
+}
+function normalizeRows(value, min) {
+  if (!Number.isFinite(value)) {
+    return min;
+  }
+  return Math.max(min, Math.floor(value));
+}
+function lineHeightFromStyle(style) {
+  return pixelValue(style.lineHeight) || (pixelValue(style.fontSize) || 16) * 1.2;
+}
+function pixelValue(value) {
+  const parsed = Number.parseFloat(value);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function promptWithQuote(prompt, quote) {
+  const quotedText = quote.text.split(/\r?\n/).map((line) => `> ${line}`).join("\n");
+  if (prompt.trim().length === 0) {
+    return quotedText;
+  }
+  return `${quotedText}
+
+${prompt}`;
+}
+function normalizeQuote(quote) {
+  if (quote === void 0) {
+    return void 0;
+  }
+  return {
+    text: quote.text,
+    messageId: quote.messageId
+  };
+}
+function composerSubmitMetadata(quote, entities) {
+  if (quote === void 0 && entities.length === 0) {
+    return void 0;
+  }
+  return {
+    ...quote === void 0 ? {} : { quote },
+    ...entities.length === 0 ? {} : {
+      composer: {
+        entities
+      }
+    }
+  };
+}
+var ComposerSubmit = forwardRef(
+  function ComposerSubmit2(props, ref) {
+    const composer = useComposer();
+    const disabled = props.disabled ?? !composer.canSubmit;
+    return renderPrimitive(
+      "button",
+      {
+        ...props,
+        children: props.children ?? "Send",
+        disabled,
+        type: props.type ?? "submit",
+        "data-anvia-submit": "",
+        "data-state": disabled ? "disabled" : "enabled"
+      },
+      ref
+    );
+  }
+);
+var ComposerStop = forwardRef(function ComposerStop2({ onClick, ...props }, ref) {
+  const composer = useComposer();
+  const disabled = props.disabled ?? !composer.canStop;
+  const handleClick = useCallback(
+    (event) => {
+      onClick?.(event);
+      if (event.defaultPrevented || disabled) {
+        return;
+      }
+      composer.stop();
+    },
+    [composer, disabled, onClick]
+  );
+  return renderPrimitive(
+    "button",
+    {
+      ...props,
+      children: props.children ?? "Stop",
+      disabled,
+      onClick: handleClick,
+      type: props.type ?? "button",
+      "data-anvia-stop": "",
+      "data-state": disabled ? "disabled" : "enabled"
+    },
+    ref
+  );
+});
+var ComposerTriggerMenu = forwardRef(
+  function ComposerTriggerMenu2({ children, keepMounted = false, style, ...props }, ref) {
+    const composer = useComposer();
+    const activeTrigger = composer.activeTrigger;
+    const empty = activeTrigger === void 0;
+    if (empty && !keepMounted) {
+      return null;
+    }
+    const menuStyle = activeTrigger?.rect === void 0 ? style : {
+      position: "fixed",
+      top: activeTrigger.rect.bottom,
+      left: activeTrigger.rect.left,
+      ...style
+    };
+    const renderedChildren = activeTrigger === void 0 ? typeof children === "function" ? null : children : typeof children === "function" ? children(activeTrigger) : children ?? activeTrigger.items.map((item, index) => /* @__PURE__ */ jsx(ComposerTriggerItem, { index }, `${item.id}:${index.toString()}`));
+    return renderPrimitive(
+      "div",
+      {
+        ...props,
+        children: renderedChildren,
+        role: props.role ?? "listbox",
+        style: menuStyle,
+        "data-anvia-composer-trigger-menu": "",
+        "data-empty": empty ? "" : void 0,
+        "data-loading": activeTrigger?.loading ? "" : void 0,
+        "data-trigger": activeTrigger?.trigger.char,
+        "data-trigger-id": activeTrigger?.trigger.id
+      },
+      ref
+    );
+  }
+);
+var ComposerTriggerItem = forwardRef(
+  function ComposerTriggerItem2({ children, index, item: itemProp, onClick, onMouseEnter, ...props }, ref) {
+    const composer = useComposer();
+    const activeTrigger = composer.activeTrigger;
+    const itemIndex = index ?? 0;
+    const item = itemProp ?? activeTrigger?.items[itemIndex];
+    if (activeTrigger === void 0 || item === void 0) {
+      return null;
+    }
+    const selected = activeTrigger.selectedIndex === itemIndex;
+    const disabled = props.disabled ?? item.disabled ?? false;
+    const renderedChildren = typeof children === "function" ? children(item, activeTrigger) : children ?? item.label;
+    const handleMouseEnter = (event) => {
+      onMouseEnter?.(event);
+      if (!event.defaultPrevented && !disabled) {
+        activeTrigger.setSelectedIndex(itemIndex);
+      }
+    };
+    const handleClick = (event) => {
+      onClick?.(event);
+      if (!event.defaultPrevented && !disabled) {
+        activeTrigger.selectItem(item);
+      }
+    };
+    return renderPrimitive(
+      "button",
+      {
+        ...props,
+        children: renderedChildren,
+        disabled,
+        onClick: handleClick,
+        onMouseEnter: handleMouseEnter,
+        role: props.role ?? "option",
+        type: props.type ?? "button",
+        "aria-selected": selected,
+        "data-anvia-composer-trigger-item": "",
+        "data-disabled": disabled ? "" : void 0,
+        "data-item-id": item.id,
+        "data-selected": selected ? "" : void 0,
+        "data-trigger": activeTrigger.trigger.char,
+        "data-trigger-id": activeTrigger.trigger.id
+      },
+      ref
+    );
+  }
+);
+var ComposerAttachments = forwardRef(
+  function ComposerAttachments2({ children, keepMounted = false, ...props }, ref) {
+    const composer = useComposer();
+    const empty = composer.attachments.length === 0;
+    if (empty && !keepMounted) {
+      return null;
+    }
+    return renderPrimitive(
+      "div",
+      {
+        ...props,
+        children: composer.attachments.map((attachment) => /* @__PURE__ */ jsx(
+          InternalAttachmentProvider,
+          {
+            value: {
+              attachment,
+              remove: () => {
+                composer.removeAttachment(attachment.id);
+              }
+            },
+            children: typeof children === "function" ? children(attachment) : children ?? /* @__PURE__ */ jsx(Attachment.Root, {})
+          },
+          attachment.id
+        )),
+        "data-anvia-composer-attachments": "",
+        "data-empty": empty ? "" : void 0
+      },
+      ref
+    );
+  }
+);
+var ComposerAttachmentInput = forwardRef(
+  function ComposerAttachmentInput2({ onChange, ...props }, ref) {
+    const composer = useComposer();
+    const disabled = props.disabled ?? composer.status === "streaming";
+    const handleChange = useCallback(
+      async (event) => {
+        onChange?.(event);
+        if (event.defaultPrevented) {
+          return;
+        }
+        const files = Array.from(event.currentTarget.files ?? []);
+        event.currentTarget.value = "";
+        for (const file of files) {
+          await composer.addAttachment(file);
+        }
+      },
+      [composer, onChange]
+    );
+    return renderPrimitive(
+      "input",
+      {
+        ...props,
+        disabled,
+        onChange: (event) => {
+          void handleChange(event);
+        },
+        type: "file",
+        "data-anvia-attachment-input": "",
+        "data-state": disabled ? "disabled" : "enabled"
+      },
+      ref
+    );
+  }
+);
+var ComposerAddAttachment = forwardRef(
+  function ComposerAddAttachment2({ accept, multiple = false, onClick, ...props }, ref) {
+    const composer = useComposer();
+    const inputRef = useRef(null);
+    const disabled = props.disabled ?? composer.status === "streaming";
+    const handleClick = useCallback(
+      (event) => {
+        onClick?.(event);
+        if (event.defaultPrevented || disabled) {
+          return;
+        }
+        inputRef.current?.click();
+      },
+      [disabled, onClick]
+    );
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      renderPrimitive(
+        "button",
+        {
+          ...props,
+          children: props.children ?? "Attach",
+          disabled,
+          onClick: handleClick,
+          type: props.type ?? "button",
+          "data-anvia-add-attachment": "",
+          "data-state": disabled ? "disabled" : "enabled"
+        },
+        ref
+      ),
+      /* @__PURE__ */ jsx(
+        ComposerAttachmentInput,
+        {
+          accept,
+          "aria-hidden": "true",
+          hidden: true,
+          multiple,
+          ref: inputRef,
+          tabIndex: -1
+        }
+      )
+    ] });
+  }
+);
+var ComposerAttachmentDropzone = forwardRef(
+  function ComposerAttachmentDropzone2({ disabled: disabledProp = false, onDragLeave, onDragOver, onDrop, ...props }, ref) {
+    const composer = useComposer();
+    const [dragging, setDragging] = useState(false);
+    const disabled = disabledProp || composer.status === "streaming";
+    const handleDragOver = useCallback(
+      (event) => {
+        onDragOver?.(event);
+        if (event.defaultPrevented || disabled) {
+          return;
+        }
+        event.preventDefault();
+        setDragging(true);
+      },
+      [disabled, onDragOver]
+    );
+    const handleDragLeave = useCallback(
+      (event) => {
+        onDragLeave?.(event);
+        if (!event.defaultPrevented) {
+          setDragging(false);
+        }
+      },
+      [onDragLeave]
+    );
+    const handleDrop = useCallback(
+      (event) => {
+        onDrop?.(event);
+        if (event.defaultPrevented || disabled) {
+          return;
+        }
+        event.preventDefault();
+        setDragging(false);
+        const files = Array.from(event.dataTransfer.files);
+        void Promise.all(files.map((file) => composer.addAttachment(file)));
+      },
+      [composer, disabled, onDrop]
+    );
+    return renderPrimitive(
+      "div",
+      {
+        ...props,
+        onDragLeave: handleDragLeave,
+        onDragOver: handleDragOver,
+        onDrop: handleDrop,
+        "data-anvia-attachment-dropzone": "",
+        "data-dragging": dragging ? "" : void 0,
+        "data-state": disabled ? "disabled" : "enabled"
+      },
+      ref
+    );
+  }
+);
+function createAttachment(attachment) {
+  return {
+    ...attachment,
+    id: attachment.id ?? createAttachmentId()
+  };
+}
+function isFileAttachmentInput(attachment) {
+  return typeof File !== "undefined" && attachment instanceof File;
+}
+async function attachmentFromFile(file) {
+  return {
+    id: createAttachmentId(),
+    type: file.type.startsWith("image/") ? "image" : "document",
+    name: file.name,
+    mediaType: file.type.length > 0 ? file.type : "application/octet-stream",
+    data: await readFileData(file)
+  };
+}
+async function readFileData(file) {
+  const dataUrl = await new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.addEventListener("load", () => {
+      resolve(String(reader.result ?? ""));
+    });
+    reader.addEventListener("error", () => {
+      reject(reader.error ?? new Error("Failed to read attachment."));
+    });
+    reader.readAsDataURL(file);
+  });
+  return dataUrl.includes(",") ? dataUrl.slice(dataUrl.indexOf(",") + 1) : dataUrl;
+}
+var nextAttachmentId = 0;
+function createAttachmentId() {
+  const random = globalThis.crypto?.randomUUID?.();
+  if (random !== void 0) {
+    return `attachment_${random}`;
+  }
+  nextAttachmentId += 1;
+  return `attachment_${nextAttachmentId.toString(36)}`;
+}
+var Composer = {
+  Root: ComposerRoot,
+  Quote: ComposerQuotePreview,
+  ClearQuote: ComposerClearQuote,
+  Input: ComposerInput,
+  TextareaInput: ComposerTextareaInput,
+  TriggerMenu: ComposerTriggerMenu,
+  TriggerItem: ComposerTriggerItem,
+  Attachments: ComposerAttachments,
+  AddAttachment: ComposerAddAttachment,
+  AttachmentInput: ComposerAttachmentInput,
+  AttachmentDropzone: ComposerAttachmentDropzone,
+  Submit: ComposerSubmit,
+  Stop: ComposerStop
+};
+
+// src/chat/thread.tsx
+import {
+  Fragment as Fragment2,
+  forwardRef as forwardRef2,
+  useCallback as useCallback2,
+  useEffect as useEffect2,
+  useMemo as useMemo2,
+  useRef as useRef2,
+  useState as useState2
+} from "react";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var ThreadRoot = forwardRef2(
+  function ThreadRoot2(props, ref) {
+    const chat = useChatContext();
+    const viewportRef = useRef2(null);
+    const [atBottom, setAtBottom] = useState2(true);
+    const scrollToBottom = useCallback2((behavior = "smooth") => {
+      const viewport = viewportRef.current;
+      if (viewport === null) {
+        return;
+      }
+      viewport.scrollTo({ top: viewport.scrollHeight, behavior });
+    }, []);
+    const thread = useMemo2(
+      () => ({ viewportRef, atBottom, setAtBottom, scrollToBottom }),
+      [atBottom, scrollToBottom]
+    );
+    return /* @__PURE__ */ jsx2(InternalThreadProvider, { value: thread, children: renderPrimitive(
+      "div",
+      {
+        ...props,
+        "data-anvia-thread": "",
+        "data-state": chat.status
+      },
+      ref
+    ) });
+  }
+);
+var ThreadViewport = forwardRef2(function ThreadViewport2({ autoScroll = true, onScroll, ...props }, ref) {
+  const chat = useChatContext();
+  const thread = useThread();
+  const messages = chat.messages;
+  const composedRef = useMemo2(
+    () => composeRefs(ref, (node) => {
+      thread.viewportRef.current = node;
+    }),
+    [ref, thread.viewportRef]
+  );
+  useEffect2(() => {
+    const hasMessages = messages.length > 0;
+    if (autoScroll && (thread.atBottom || !hasMessages)) {
+      thread.scrollToBottom("auto");
+    }
+  }, [autoScroll, messages, thread]);
+  const handleScroll = useCallback2(
+    (event) => {
+      onScroll?.(event);
+      const node = event.currentTarget;
+      const distanceFromBottom = node.scrollHeight - node.scrollTop - node.clientHeight;
+      thread.setAtBottom(distanceFromBottom < 8);
+    },
+    [onScroll, thread]
+  );
+  return renderPrimitive(
+    "div",
+    {
+      ...props,
+      onScroll: handleScroll,
+      "data-anvia-thread-viewport": "",
+      "data-state": thread.atBottom ? "bottom" : "away"
+    },
+    composedRef
+  );
+});
+var ThreadViewportFooter = forwardRef2(
+  function ThreadViewportFooter2(props, ref) {
+    return renderPrimitive(
+      "div",
+      {
+        ...props,
+        "data-anvia-thread-viewport-footer": ""
+      },
+      ref
+    );
+  }
+);
+var ThreadEmpty = forwardRef2(
+  function ThreadEmpty2(props, ref) {
+    const chat = useChatContext();
+    if (chat.messages.length > 0) {
+      return null;
+    }
+    return renderPrimitive(
+      "div",
+      {
+        ...props,
+        "data-anvia-thread-empty": ""
+      },
+      ref
+    );
+  }
+);
+var ThreadStatus = forwardRef2(function ThreadStatus2({ children, ...props }, ref) {
+  const chat = useChatContext();
+  const renderedChildren = typeof children === "function" ? children(chat.status) : children;
+  return renderPrimitive(
+    "div",
+    {
+      ...props,
+      children: renderedChildren ?? chat.status,
+      "data-anvia-thread-status": "",
+      "data-state": chat.status
+    },
+    ref
+  );
+});
+var ThreadLoading = forwardRef2(
+  function ThreadLoading2(props, ref) {
+    const chat = useChatContext();
+    if (chat.status !== "streaming") {
+      return null;
+    }
+    return renderPrimitive(
+      "div",
+      {
+        ...props,
+        children: props.children ?? "Loading",
+        "data-anvia-thread-loading": ""
+      },
+      ref
+    );
+  }
+);
+var ThreadError = forwardRef2(function ThreadError2({ children, ...props }, ref) {
+  const chat = useChatContext();
+  if (chat.status !== "error" && chat.error === void 0) {
+    return null;
+  }
+  const renderedChildren = typeof children === "function" ? children(chat.error) : children;
+  return renderPrimitive(
+    "div",
+    {
+      ...props,
+      children: renderedChildren ?? errorMessage(chat.error),
+      "data-anvia-thread-error": "",
+      role: props.role ?? "alert"
+    },
+    ref
+  );
+});
+var ThreadMessages = forwardRef2(function ThreadMessages2({ children, keepMounted = true, ...props }, ref) {
+  const chat = useChatContext();
+  const empty = chat.messages.length === 0;
+  if (empty && !keepMounted) {
+    return null;
+  }
+  return renderPrimitive(
+    "div",
+    {
+      ...props,
+      children: chat.messages.map((message) => /* @__PURE__ */ jsx2(InternalMessageProvider, { message, children: typeof children === "function" ? children(message) : children ?? defaultMessage() }, message.id)),
+      "data-anvia-thread-messages": "",
+      "data-empty": empty ? "" : void 0
+    },
+    ref
+  );
+});
+var ThreadSuggestions = forwardRef2(
+  function ThreadSuggestions2({ children, keepMounted = false, ...props }, ref) {
+    const chat = useChatContext();
+    const suggestions = chat.suggestions ?? [];
+    const empty = suggestions.length === 0;
+    if (empty && !keepMounted) {
+      return null;
+    }
+    return renderPrimitive(
+      "div",
+      {
+        ...props,
+        children: suggestions.map(
+          (suggestion) => typeof children === "function" ? /* @__PURE__ */ jsx2(Fragment2, { children: children(suggestion) }, suggestion.id) : /* @__PURE__ */ jsx2(ThreadSuggestion, { suggestion, children }, suggestion.id)
+        ),
+        "data-anvia-thread-suggestions": "",
+        "data-empty": empty ? "" : void 0
+      },
+      ref
+    );
+  }
+);
+var ThreadSuggestion = forwardRef2(
+  function ThreadSuggestion2({ onClick, prompt, suggestion, ...props }, ref) {
+    const chat = useChatContext();
+    const suggestionPrompt = prompt ?? suggestion?.prompt ?? "";
+    const disabled = props.disabled ?? (suggestionPrompt.length === 0 || chat.status === "streaming");
+    const handleClick = useCallback2(
+      (event) => {
+        onClick?.(event);
+        if (event.defaultPrevented || disabled) {
+          return;
+        }
+        void chat.sendMessage(suggestionPrompt);
+      },
+      [chat, disabled, onClick, suggestionPrompt]
+    );
+    return renderPrimitive(
+      "button",
+      {
+        ...props,
+        children: props.children ?? suggestion?.label ?? suggestionPrompt,
+        disabled,
+        onClick: handleClick,
+        type: props.type ?? "button",
+        "data-anvia-thread-suggestion": "",
+        "data-state": disabled ? "disabled" : "enabled"
+      },
+      ref
+    );
+  }
+);
+var ThreadScrollToBottom = forwardRef2(
+  function ThreadScrollToBottom2({ onClick, ...props }, ref) {
+    const thread = useThread();
+    const disabled = props.disabled ?? thread.atBottom;
+    const handleClick = useCallback2(
+      (event) => {
+        onClick?.(event);
+        if (event.defaultPrevented || disabled) {
+          return;
+        }
+        thread.scrollToBottom();
+      },
+      [disabled, onClick, thread]
+    );
+    return renderPrimitive(
+      "button",
+      {
+        ...props,
+        children: props.children ?? "Scroll to bottom",
+        disabled,
+        onClick: handleClick,
+        type: props.type ?? "button",
+        "data-anvia-scroll-to-bottom": "",
+        "data-state": thread.atBottom ? "bottom" : "away"
+      },
+      ref
+    );
+  }
+);
+function defaultMessage() {
+  return /* @__PURE__ */ jsxs2(Message.Root, { children: [
+    /* @__PURE__ */ jsx2(Message.Content, { children: /* @__PURE__ */ jsx2(Message.Parts, {}) }),
+    /* @__PURE__ */ jsx2(Message.Actions, {})
+  ] });
+}
+function errorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  return "Something went wrong.";
+}
+var Thread = {
+  Root: ThreadRoot,
+  Viewport: ThreadViewport,
+  ViewportFooter: ThreadViewportFooter,
+  Messages: ThreadMessages,
+  Empty: ThreadEmpty,
+  Status: ThreadStatus,
+  Loading: ThreadLoading,
+  Error: ThreadError,
+  Suggestions: ThreadSuggestions,
+  Suggestion: ThreadSuggestion,
+  ScrollToBottom: ThreadScrollToBottom
+};
+
+export {
+  Composer,
+  Thread
+};
+//# sourceMappingURL=chunk-KO36TK2O.js.map