@assistant-ui/react 0.12.25 → 0.12.27

package/src/primitives/composer/trigger/detectTrigger.ts

@@ -1,4 +1,4 @@
-const WHITESPACE_RE = /\s/;
+const WHITESPACE_RE = /\s/u;
 
 /**
  * Detect a trigger character in text relative to the cursor position.

package/src/primitives/composer/trigger/index.ts

@@ -1,9 +1,16 @@
 export {
   ComposerPrimitiveTriggerPopoverRoot,
-  useTriggerPopoverContext,
-  useTriggerPopoverContextOptional,
-} from "./TriggerPopoverContext";
-export { ComposerPrimitiveTriggerPopoverPopover } from "./TriggerPopoverPopover";
+  useTriggerPopoverRootContext,
+  useTriggerPopoverRootContextOptional,
+  useTriggerPopoverTriggers,
+  useTriggerPopoverTriggersOptional,
+  type RegisteredTrigger,
+  type TriggerPopoverRootContextValue,
+} from "./TriggerPopoverRootContext";
+export {
+  useTriggerPopoverScopeContext,
+  useTriggerPopoverScopeContextOptional,
+} from "./TriggerPopover";
 export {
   ComposerPrimitiveTriggerPopoverCategories,
   ComposerPrimitiveTriggerPopoverCategoryItem,
@@ -13,4 +20,13 @@ export {
   ComposerPrimitiveTriggerPopoverItem,
 } from "./TriggerPopoverItems";
 export { ComposerPrimitiveTriggerPopoverBack } from "./TriggerPopoverBack";
-export type { OnSelectBehavior } from "./TriggerPopoverResource";
+export type { TriggerBehavior } from "./triggerSelectionResource";
+
+import { ComposerPrimitiveTriggerPopover as Base } from "./TriggerPopover";
+import { ComposerPrimitiveTriggerPopoverAction } from "./TriggerPopoverAction";
+import { ComposerPrimitiveTriggerPopoverDirective } from "./TriggerPopoverDirective";
+
+export const ComposerPrimitiveTriggerPopover = Object.assign(Base, {
+  Directive: ComposerPrimitiveTriggerPopoverDirective,
+  Action: ComposerPrimitiveTriggerPopoverAction,
+});

package/src/primitives/composer/trigger/triggerDetectionResource.ts

@@ -0,0 +1,43 @@
+import { resource, tapMemo, tapState } from "@assistant-ui/tap";
+import { detectTrigger } from "./detectTrigger";
+
+/** Detected trigger position within the composer text. */
+export type DetectedTrigger = {
+  readonly offset: number;
+  readonly query: string;
+};
+
+export type TriggerDetectionResourceOutput = {
+  /** Detected trigger (or `null` when inactive). */
+  readonly trigger: DetectedTrigger | null;
+  /** Current query string (empty when no trigger active). */
+  readonly query: string;
+  /** Update the tracked cursor position (wired to composer input). */
+  setCursorPosition(pos: number): void;
+};
+
+/** Tracks cursor position and derives the active trigger + query from composer text. */
+export const TriggerDetectionResource = resource(
+  ({
+    text,
+    triggerChar,
+  }: {
+    text: string;
+    triggerChar: string;
+  }): TriggerDetectionResourceOutput => {
+    const [cursorPosition, setCursorPosition] = tapState(text.length);
+
+    const trigger = tapMemo(() => {
+      const pos = Math.min(cursorPosition, text.length);
+      return detectTrigger(text, triggerChar, pos);
+    }, [cursorPosition, text, triggerChar]);
+
+    const query = trigger?.query ?? "";
+
+    return {
+      trigger,
+      query,
+      setCursorPosition,
+    };
+  },
+);

package/src/primitives/composer/trigger/triggerKeyboardResource.ts

@@ -0,0 +1,151 @@
+import {
+  resource,
+  tapEffect,
+  tapEffectEvent,
+  tapState,
+} from "@assistant-ui/tap";
+import type {
+  Unstable_TriggerCategory,
+  Unstable_TriggerItem,
+} from "@assistant-ui/core";
+
+/** Relies on `Unstable_TriggerCategory` never carrying a `type` field. */
+function isTriggerItem(
+  x: Unstable_TriggerItem | Unstable_TriggerCategory,
+): x is Unstable_TriggerItem {
+  return "type" in x;
+}
+
+/** Key event shape accepted by the keyboard handler. */
+export type TriggerPopoverKeyEvent = {
+  readonly key: string;
+  readonly shiftKey: boolean;
+  preventDefault(): void;
+};
+
+export type TriggerKeyboardResourceOutput = {
+  /** Index of the currently highlighted entry within the navigable list. */
+  readonly highlightedIndex: number;
+  /** ID of the currently highlighted item (for `aria-activedescendant`). */
+  readonly highlightedItemId: string | undefined;
+  /** Move the highlight to an entry index (e.g. from pointer hover). Out-of-range values are ignored. */
+  highlightIndex(index: number): void;
+  /** Handle a key event; returns `true` if it was consumed. */
+  handleKeyDown(e: TriggerPopoverKeyEvent): boolean;
+};
+
+/**
+ * Owns keyboard-driven highlight state for the popover. Delegates selection,
+ * category drill-in, back, and close to the callbacks supplied by the parent.
+ */
+export const TriggerKeyboardResource = resource(
+  ({
+    navigableList,
+    isSearchMode,
+    activeCategoryId,
+    query,
+    popoverId,
+    open,
+    selectItem,
+    selectCategory,
+    goBack,
+    close,
+  }: {
+    navigableList: readonly (Unstable_TriggerCategory | Unstable_TriggerItem)[];
+    isSearchMode: boolean;
+    activeCategoryId: string | null;
+    query: string;
+    popoverId: string;
+    open: boolean;
+    selectItem: (item: Unstable_TriggerItem) => void;
+    selectCategory: (categoryId: string) => void;
+    goBack: () => void;
+    close: () => void;
+  }): TriggerKeyboardResourceOutput => {
+    const [highlightedIndex, setHighlightedIndex] = tapState(0);
+
+    // biome-ignore lint/correctness/useExhaustiveDependencies: intentional reset on list change
+    tapEffect(() => {
+      setHighlightedIndex(0);
+    }, [navigableList]);
+
+    // biome-ignore lint/correctness/useExhaustiveDependencies: intentional reset
+    tapEffect(() => {
+      setHighlightedIndex(0);
+    }, [isSearchMode, activeCategoryId]);
+
+    const highlightIndex = tapEffectEvent((index: number) => {
+      if (index < 0 || index >= navigableList.length) return;
+      if (index === highlightedIndex) return;
+      setHighlightedIndex(index);
+    });
+
+    const handleKeyDown = tapEffectEvent(
+      (e: TriggerPopoverKeyEvent): boolean => {
+        if (!open) return false;
+
+        switch (e.key) {
+          case "ArrowDown": {
+            e.preventDefault();
+            setHighlightedIndex((prev) => {
+              const len = navigableList.length;
+              if (len === 0) return 0;
+              return prev < len - 1 ? prev + 1 : 0;
+            });
+            return true;
+          }
+          case "ArrowUp": {
+            e.preventDefault();
+            setHighlightedIndex((prev) => {
+              const len = navigableList.length;
+              if (len === 0) return 0;
+              return prev > 0 ? prev - 1 : len - 1;
+            });
+            return true;
+          }
+          case "Enter": {
+            if (e.shiftKey) return false;
+            e.preventDefault();
+            const item = navigableList[highlightedIndex];
+            if (!item) return true;
+
+            if (isTriggerItem(item)) {
+              selectItem(item);
+            } else {
+              selectCategory(item.id);
+            }
+            return true;
+          }
+          case "Escape": {
+            e.preventDefault();
+            close();
+            return true;
+          }
+          case "Backspace": {
+            if (activeCategoryId && query === "") {
+              e.preventDefault();
+              goBack();
+              return true;
+            }
+            return false;
+          }
+          default:
+            return false;
+        }
+      },
+    );
+
+    const highlightedEntry = navigableList[highlightedIndex];
+    const highlightedItemId =
+      open && highlightedEntry
+        ? `${popoverId}-option-${highlightedEntry.id}`
+        : undefined;
+
+    return {
+      highlightedIndex,
+      highlightedItemId,
+      highlightIndex,
+      handleKeyDown,
+    };
+  },
+);

package/src/primitives/composer/trigger/triggerNavigationResource.ts

@@ -0,0 +1,145 @@
+import {
+  resource,
+  tapEffect,
+  tapEffectEvent,
+  tapMemo,
+  tapState,
+} from "@assistant-ui/tap";
+import type {
+  Unstable_TriggerAdapter,
+  Unstable_TriggerCategory,
+  Unstable_TriggerItem,
+} from "@assistant-ui/core";
+
+function matchesQuery(item: Unstable_TriggerItem, lower: string): boolean {
+  return (
+    item.id.toLowerCase().includes(lower) ||
+    item.label.toLowerCase().includes(lower) ||
+    (item.description?.toLowerCase().includes(lower) ?? false)
+  );
+}
+
+export type TriggerNavigationResourceOutput = {
+  /** Filtered categories visible in the list (empty in search mode). */
+  readonly categories: readonly Unstable_TriggerCategory[];
+  /** Filtered items visible in the list. */
+  readonly items: readonly Unstable_TriggerItem[];
+  /** `true` when the current list is search results rather than categories. */
+  readonly isSearchMode: boolean;
+  /** Currently drilled-into category id (or `null` for the top level). */
+  readonly activeCategoryId: string | null;
+  /** Flat list used for keyboard navigation (categories or items). */
+  readonly navigableList: readonly (
+    | Unstable_TriggerCategory
+    | Unstable_TriggerItem
+  )[];
+  /** Drill into a category. */
+  selectCategory(categoryId: string): void;
+  /** Return to the top-level category list. */
+  goBack(): void;
+};
+
+/**
+ * Computes categories, items, search results, and navigation state from the
+ * adapter + current query. Pure derivation — no side effects on the composer.
+ */
+export const TriggerNavigationResource = resource(
+  ({
+    adapter,
+    query,
+    open,
+  }: {
+    adapter: Unstable_TriggerAdapter | undefined;
+    query: string;
+    open: boolean;
+  }): TriggerNavigationResourceOutput => {
+    const [activeCategoryId, setActiveCategoryId] = tapState<string | null>(
+      null,
+    );
+
+    tapEffect(() => {
+      if (!open) setActiveCategoryId(null);
+    }, [open]);
+
+    const categories = tapMemo<readonly Unstable_TriggerCategory[]>(() => {
+      if (!open || !adapter) return [];
+      return adapter.categories();
+    }, [open, adapter]);
+
+    const effectiveActiveCategoryId = open ? activeCategoryId : null;
+
+    const allItems = tapMemo<readonly Unstable_TriggerItem[]>(() => {
+      if (!effectiveActiveCategoryId || !adapter) return [];
+      return adapter.categoryItems(effectiveActiveCategoryId);
+    }, [effectiveActiveCategoryId, adapter]);
+
+    const searchResults = tapMemo<
+      readonly Unstable_TriggerItem[] | null
+    >(() => {
+      if (!open || !adapter || effectiveActiveCategoryId) return null;
+      // If categories exist and query is empty, show categories first (not search)
+      if (!query && categories.length > 0) return null;
+      if (adapter.search) return adapter.search(query);
+
+      // fallback: no adapter.search
+      const all: Unstable_TriggerItem[] = [];
+      const lower = query.toLowerCase();
+      for (const cat of categories) {
+        for (const item of adapter.categoryItems(cat.id)) {
+          if (matchesQuery(item, lower)) {
+            all.push(item);
+          }
+        }
+      }
+      return all;
+    }, [open, adapter, query, effectiveActiveCategoryId, categories]);
+
+    const isSearchMode = searchResults !== null;
+
+    const filteredCategories = tapMemo(() => {
+      if (isSearchMode) return [];
+      if (!query) return categories;
+      const lower = query.toLowerCase();
+      return categories.filter((cat) =>
+        cat.label.toLowerCase().includes(lower),
+      );
+    }, [categories, query, isSearchMode]);
+
+    const filteredItems = tapMemo(() => {
+      if (isSearchMode) return searchResults ?? [];
+      if (!query) return allItems;
+      const lower = query.toLowerCase();
+      return allItems.filter((item) => matchesQuery(item, lower));
+    }, [allItems, query, isSearchMode, searchResults]);
+
+    const navigableList = tapMemo(() => {
+      if (isSearchMode) return searchResults ?? [];
+      if (effectiveActiveCategoryId) return filteredItems;
+      return filteredCategories;
+    }, [
+      isSearchMode,
+      searchResults,
+      effectiveActiveCategoryId,
+      filteredItems,
+      filteredCategories,
+    ]);
+
+    const selectCategory = tapEffectEvent((categoryId: string) => {
+      setActiveCategoryId(categoryId);
+    });
+
+    const goBack = tapEffectEvent(() => {
+      setActiveCategoryId(null);
+    });
+
+    return {
+      categories: filteredCategories,
+      items: filteredItems,
+      isSearchMode,
+      activeCategoryId: effectiveActiveCategoryId,
+      navigableList,
+      selectCategory,
+      goBack,
+    };
+  },
+);

package/src/primitives/composer/trigger/triggerSelectionResource.ts

@@ -0,0 +1,122 @@
+import { resource, tapEffectEvent, tapRef } from "@assistant-ui/tap";
+import type {
+  Unstable_DirectiveFormatter,
+  Unstable_TriggerItem,
+} from "@assistant-ui/core";
+import type { AssistantClient } from "@assistant-ui/store";
+import type { DetectedTrigger } from "./triggerDetectionResource";
+
+/** External override for selection (used by Lexical's DirectivePlugin). */
+export type SelectItemOverride = (item: Unstable_TriggerItem) => boolean;
+
+export type TriggerBehavior =
+  | {
+      readonly kind: "directive";
+      readonly formatter: Unstable_DirectiveFormatter;
+      readonly onInserted?: (item: Unstable_TriggerItem) => void;
+    }
+  | {
+      readonly kind: "action";
+      readonly formatter: Unstable_DirectiveFormatter;
+      readonly onExecute: (item: Unstable_TriggerItem) => void;
+      readonly removeOnExecute?: boolean;
+    };
+
+export type TriggerSelectionResourceOutput = {
+  /** Select an item — runs override (if any) then applies behavior. */
+  selectItem(item: Unstable_TriggerItem): void;
+  /** Close the popover (moves cursor before trigger to deactivate detection). */
+  close(): void;
+  /** Register a Lexical-style selection override. Returns unregister fn. */
+  registerSelectItemOverride(fn: SelectItemOverride): () => void;
+};
+
+/** Owns composer text mutation + behavior dispatch on item selection. */
+export const TriggerSelectionResource = resource(
+  ({
+    behavior,
+    trigger,
+    aui,
+    triggerChar,
+    setCursorPosition,
+    onSelected,
+  }: {
+    behavior: TriggerBehavior | undefined;
+    trigger: DetectedTrigger | null;
+    aui: AssistantClient;
+    triggerChar: string;
+    setCursorPosition: (pos: number) => void;
+    /** Called after a successful selection so the parent can reset nav state. */
+    onSelected: () => void;
+  }): TriggerSelectionResourceOutput => {
+    // Select-item override: lets Lexical's DirectivePlugin intercept selection
+    // and drive its own node insertion.
+    const selectItemOverrideRef = tapRef<SelectItemOverride | null>(null);
+
+    const registerSelectItemOverride = tapEffectEvent(
+      (fn: SelectItemOverride) => {
+        selectItemOverrideRef.current = fn;
+        return () => {
+          if (selectItemOverrideRef.current === fn) {
+            selectItemOverrideRef.current = null;
+          }
+        };
+      },
+    );
+
+    const selectItem = tapEffectEvent((item: Unstable_TriggerItem) => {
+      if (!trigger || !behavior) return;
+
+      if (selectItemOverrideRef.current?.(item)) {
+        onSelected();
+        return;
+      }
+
+      const currentText = aui.composer().getState().text;
+      const before = currentText.slice(0, trigger.offset);
+      const after = currentText.slice(
+        trigger.offset + triggerChar.length + trigger.query.length,
+      );
+
+      const insertDirective = () => {
+        const directive = behavior.formatter.serialize(item);
+        aui
+          .composer()
+          .setText(
+            before + directive + (after.startsWith(" ") ? after : ` ${after}`),
+          );
+      };
+
+      if (behavior.kind === "directive") {
+        insertDirective();
+        behavior.onInserted?.(item);
+      } else {
+        if (behavior.removeOnExecute) {
+          aui
+            .composer()
+            .setText(before + (after.startsWith(" ") ? after.slice(1) : after));
+        } else {
+          // Leave directive chip in the composer as an audit trail
+          insertDirective();
+        }
+        behavior.onExecute(item);
+      }
+
+      onSelected();
+    });
+
+    const close = tapEffectEvent(() => {
+      onSelected();
+      // Move cursor before the trigger so trigger detection deactivates
+      if (trigger) {
+        setCursorPosition(trigger.offset);
+      }
+    });
+
+    return {
+      selectItem,
+      close,
+      registerSelectItemOverride,
+    };
+  },
+);

package/src/primitives/composer.ts

@@ -14,28 +14,18 @@ export { ComposerPrimitiveQuote as Quote } from "./composer/ComposerQuote";
 export { ComposerPrimitiveQuoteText as QuoteText } from "./composer/ComposerQuote";
 export { ComposerPrimitiveQuoteDismiss as QuoteDismiss } from "./composer/ComposerQuote";
 export { ComposerPrimitiveQueue as Queue } from "./composer/ComposerQueue";
-export { ComposerPrimitiveMentionRoot as Unstable_MentionRoot } from "./composer/mention";
-export { ComposerPrimitiveMentionPopover as Unstable_MentionPopover } from "./composer/mention";
-export { ComposerPrimitiveMentionCategories as Unstable_MentionCategories } from "./composer/mention";
-export { ComposerPrimitiveMentionCategoryItem as Unstable_MentionCategoryItem } from "./composer/mention";
-export { ComposerPrimitiveMentionItems as Unstable_MentionItems } from "./composer/mention";
-export { ComposerPrimitiveMentionItem as Unstable_MentionItem } from "./composer/mention";
-export { ComposerPrimitiveMentionBack as Unstable_MentionBack } from "./composer/mention";
-export { useMentionContext as unstable_useMentionContext } from "./composer/mention";
-export { useMentionContextOptional as unstable_useMentionContextOptional } from "./composer/mention";
 
-// --- Generic Trigger Popover primitives (unstable) ---
+export { ComposerPrimitiveTriggerPopover as Unstable_TriggerPopover } from "./composer/trigger";
 export { ComposerPrimitiveTriggerPopoverRoot as Unstable_TriggerPopoverRoot } from "./composer/trigger";
-export { ComposerPrimitiveTriggerPopoverPopover as Unstable_TriggerPopoverPopover } from "./composer/trigger";
 export { ComposerPrimitiveTriggerPopoverCategories as Unstable_TriggerPopoverCategories } from "./composer/trigger";
 export { ComposerPrimitiveTriggerPopoverCategoryItem as Unstable_TriggerPopoverCategoryItem } from "./composer/trigger";
 export { ComposerPrimitiveTriggerPopoverItems as Unstable_TriggerPopoverItems } from "./composer/trigger";
 export { ComposerPrimitiveTriggerPopoverItem as Unstable_TriggerPopoverItem } from "./composer/trigger";
 export { ComposerPrimitiveTriggerPopoverBack as Unstable_TriggerPopoverBack } from "./composer/trigger";
-export { useTriggerPopoverContext as unstable_useTriggerPopoverContext } from "./composer/trigger";
-export { useTriggerPopoverContextOptional as unstable_useTriggerPopoverContextOptional } from "./composer/trigger";
-
-// --- Slash Command primitives (unstable) ---
-// SlashCommandRoot is the only slash-specific primitive; UI primitives
-// (Popover, Items, Categories, Back) are the shared TriggerPopover* set above.
-export { ComposerPrimitiveSlashCommandRoot as Unstable_SlashCommandRoot } from "./composer/slash-command";
+export { useTriggerPopoverRootContext as unstable_useTriggerPopoverRootContext } from "./composer/trigger";
+export { useTriggerPopoverRootContextOptional as unstable_useTriggerPopoverRootContextOptional } from "./composer/trigger";
+export { useTriggerPopoverScopeContext as unstable_useTriggerPopoverScopeContext } from "./composer/trigger";
+export { useTriggerPopoverScopeContextOptional as unstable_useTriggerPopoverScopeContextOptional } from "./composer/trigger";
+export { useTriggerPopoverTriggers as unstable_useTriggerPopoverTriggers } from "./composer/trigger";
+export { useTriggerPopoverTriggersOptional as unstable_useTriggerPopoverTriggersOptional } from "./composer/trigger";
+export type { RegisteredTrigger as Unstable_RegisteredTrigger } from "./composer/trigger";

package/src/primitives/dropdownMenuRenderPrimitives.test.tsx

@@ -0,0 +1,64 @@
+import { renderToStaticMarkup } from "react-dom/server";
+import { describe, expect, it } from "vitest";
+import * as ActionBarMorePrimitive from "./actionBarMore";
+import * as ThreadListItemMorePrimitive from "./threadListItemMore";
+
+describe("dropdown menu primitive render props", () => {
+  it.each([
+    [
+      "ActionBarMorePrimitive.Trigger",
+      ActionBarMorePrimitive.Root,
+      ActionBarMorePrimitive.Trigger,
+    ],
+    [
+      "ThreadListItemMorePrimitive.Trigger",
+      ThreadListItemMorePrimitive.Root,
+      ThreadListItemMorePrimitive.Trigger,
+    ],
+  ])("%s render matches asChild", (_name, Root, Trigger) => {
+    const renderHtml = renderToStaticMarkup(
+      <Root open>
+        <Trigger render={<button type="button" className="trigger" />}>
+          More
+        </Trigger>
+      </Root>,
+    );
+
+    const asChildHtml = renderToStaticMarkup(
+      <Root open>
+        <Trigger asChild>
+          <button type="button" className="trigger">
+            More
+          </button>
+        </Trigger>
+      </Root>,
+    );
+
+    expect(renderHtml).toBe(asChildHtml);
+  });
+
+  it("accepts render on all affected dropdown menu primitives", () => {
+    const actionBarTree = (
+      <ActionBarMorePrimitive.Root open>
+        <ActionBarMorePrimitive.Trigger render={<button type="button" />} />
+        <ActionBarMorePrimitive.Content render={<div />} />
+        <ActionBarMorePrimitive.Item render={<div />} />
+        <ActionBarMorePrimitive.Separator render={<div />} />
+      </ActionBarMorePrimitive.Root>
+    );
+
+    const threadListItemTree = (
+      <ThreadListItemMorePrimitive.Root open>
+        <ThreadListItemMorePrimitive.Trigger
+          render={<button type="button" />}
+        />
+        <ThreadListItemMorePrimitive.Content render={<div />} />
+        <ThreadListItemMorePrimitive.Item render={<div />} />
+        <ThreadListItemMorePrimitive.Separator render={<div />} />
+      </ThreadListItemMorePrimitive.Root>
+    );
+
+    expect(actionBarTree).toBeTruthy();
+    expect(threadListItemTree).toBeTruthy();
+  });
+});

package/src/primitives/dropdownMenuRenderPrimitives.ts

@@ -0,0 +1,15 @@
+import { DropdownMenu as DropdownMenuPrimitive } from "radix-ui";
+import { withRenderProp } from "../utils/Primitive";
+
+export const DropdownMenuRenderTrigger = withRenderProp(
+  DropdownMenuPrimitive.Trigger,
+);
+export const DropdownMenuRenderContent = withRenderProp(
+  DropdownMenuPrimitive.Content,
+);
+export const DropdownMenuRenderItem = withRenderProp(
+  DropdownMenuPrimitive.Item,
+);
+export const DropdownMenuRenderSeparator = withRenderProp(
+  DropdownMenuPrimitive.Separator,
+);

package/src/primitives/error/ErrorMessage.tsx

@@ -1,7 +1,11 @@
 "use client";
 
 import { Primitive } from "../../utils/Primitive";
-import { type ComponentRef, forwardRef, ComponentPropsWithoutRef } from "react";
+import {
+  type ComponentRef,
+  forwardRef,
+  type ComponentPropsWithoutRef,
+} from "react";
 import { useMessageError } from "@assistant-ui/core/react";
 
 export namespace ErrorPrimitiveMessage {

package/src/primitives/error/ErrorRoot.tsx

@@ -1,7 +1,11 @@
 "use client";
 
 import { Primitive } from "../../utils/Primitive";
-import { type ComponentRef, forwardRef, ComponentPropsWithoutRef } from "react";
+import {
+  type ComponentRef,
+  forwardRef,
+  type ComponentPropsWithoutRef,
+} from "react";
 
 export namespace ErrorPrimitiveRoot {
   export type Element = ComponentRef<typeof Primitive.div>;

package/src/primitives/message/MessageError.ts

@@ -1,6 +1,6 @@
 "use client";
 
-import { FC, PropsWithChildren } from "react";
+import type { FC, PropsWithChildren } from "react";
 import { useMessageError } from "@assistant-ui/core/react";
 
 export const MessagePrimitiveError: FC<PropsWithChildren> = ({ children }) => {

package/src/primitives/message/MessageIf.ts

@@ -55,7 +55,7 @@ const useMessageIf = (props: UseMessageIfProps) => {
     if (
       props.hasAttachments === false &&
       role === "user" &&
-      !!attachments?.length
+      attachments?.length
     )
       return false;
 

package/src/primitives/message/MessagePartsGrouped.tsx

@@ -4,7 +4,7 @@ import {
   type ComponentType,
   type FC,
   memo,
-  PropsWithChildren,
+  type PropsWithChildren,
   useMemo,
 } from "react";
 import { useAuiState, useAui } from "@assistant-ui/store";