@assistant-ui/react 0.11.53 → 0.11.55

package/src/legacy-runtime/runtime-cores/composer/BaseComposerRuntimeCore.tsx

@@ -1,16 +1,18 @@
-import {
+import type {
   Attachment,
   CompleteAttachment,
   PendingAttachment,
 } from "../../../types/AttachmentTypes";
-import { AppendMessage } from "../../../types";
-import { AttachmentAdapter } from "../adapters/attachment";
-import {
+import type { AppendMessage, Unsubscribe } from "../../../types";
+import type { AttachmentAdapter } from "../adapters/attachment";
+import type {
   ComposerRuntimeCore,
   ComposerRuntimeEventType,
+  DictationState,
 } from "../core/ComposerRuntimeCore";
-import { MessageRole, RunConfig } from "../../../types/AssistantTypes";
+import type { MessageRole, RunConfig } from "../../../types/AssistantTypes";
 import { BaseSubscribable } from "../remote-thread-list/BaseSubscribable";
+import type { DictationAdapter } from "../adapters/speech/SpeechAdapterTypes";
 
 const isAttachmentComplete = (a: Attachment): a is CompleteAttachment =>
   a.status.type === "complete";
@@ -22,6 +24,7 @@ export abstract class BaseComposerRuntimeCore
   public readonly isEditing = true;
 
   protected abstract getAttachmentAdapter(): AttachmentAdapter | undefined;
+  protected abstract getDictationAdapter(): DictationAdapter | undefined;
 
   public get attachmentAccept(): string {
     return this.getAttachmentAdapter()?.accept ?? "*";
@@ -65,6 +68,15 @@ export abstract class BaseComposerRuntimeCore
     if (this._text === value) return;
 
     this._text = value;
+    // When dictation is active and the user manually edits the composer text,
+    // treat the new text as the updated base so speech results are appended
+    // instead of overwriting manual edits.
+    if (this._dictation) {
+      this._dictationBaseText = value;
+      this._currentInterimText = "";
+      const { status, inputDisabled } = this._dictation;
+      this._dictation = inputDisabled ? { status, inputDisabled } : { status };
+    }
     this._notifySubscribers();
   }
 
@@ -121,6 +133,11 @@ export abstract class BaseComposerRuntimeCore
   }
 
   public async send() {
+    if (this._dictationSession) {
+      this._dictationSession.cancel();
+      this._cleanupDictation();
+    }
+
     const adapter = this.getAttachmentAdapter();
     const attachments =
       adapter && this.attachments.length > 0
@@ -209,6 +226,155 @@ export abstract class BaseComposerRuntimeCore
     this._notifySubscribers();
   }
 
+  private _dictation: DictationState | undefined;
+  private _dictationSession: DictationAdapter.Session | undefined;
+  private _dictationUnsubscribes: Unsubscribe[] = [];
+  private _dictationBaseText = "";
+  private _currentInterimText = "";
+  private _dictationSessionIdCounter = 0;
+  private _activeDictationSessionId: number | undefined;
+  private _isCleaningDictation = false;
+
+  public get dictation(): DictationState | undefined {
+    return this._dictation;
+  }
+
+  private _isActiveSession(
+    sessionId: number,
+    session: DictationAdapter.Session,
+  ): boolean {
+    return (
+      this._activeDictationSessionId === sessionId &&
+      this._dictationSession === session
+    );
+  }
+
+  public startDictation(): void {
+    const adapter = this.getDictationAdapter();
+    if (!adapter) {
+      throw new Error("Dictation adapter not configured");
+    }
+
+    if (this._dictationSession) {
+      for (const unsub of this._dictationUnsubscribes) {
+        unsub();
+      }
+      this._dictationUnsubscribes = [];
+      const oldSession = this._dictationSession;
+      oldSession.stop().catch(() => {});
+      this._dictationSession = undefined;
+    }
+
+    const inputDisabled = adapter.disableInputDuringDictation ?? false;
+
+    this._dictationBaseText = this._text;
+    this._currentInterimText = "";
+
+    const session = adapter.listen();
+    this._dictationSession = session;
+    const sessionId = ++this._dictationSessionIdCounter;
+    this._activeDictationSessionId = sessionId;
+    this._dictation = { status: session.status, inputDisabled };
+    this._notifySubscribers();
+
+    const unsubSpeech = session.onSpeech((result) => {
+      if (!this._isActiveSession(sessionId, session)) return;
+      const isFinal = result.isFinal !== false;
+
+      const needsSeparator =
+        this._dictationBaseText &&
+        !this._dictationBaseText.endsWith(" ") &&
+        result.transcript;
+      const separator = needsSeparator ? " " : "";
+
+      if (isFinal) {
+        this._dictationBaseText =
+          this._dictationBaseText + separator + result.transcript;
+        this._currentInterimText = "";
+        this._text = this._dictationBaseText;
+
+        if (this._dictation) {
+          const { transcript: _, ...rest } = this._dictation;
+          this._dictation = rest;
+        }
+        this._notifySubscribers();
+      } else {
+        this._currentInterimText = separator + result.transcript;
+        this._text = this._dictationBaseText + this._currentInterimText;
+
+        if (this._dictation) {
+          this._dictation = {
+            ...this._dictation,
+            transcript: result.transcript,
+          };
+        }
+        this._notifySubscribers();
+      }
+    });
+    this._dictationUnsubscribes.push(unsubSpeech);
+
+    const unsubStart = session.onSpeechStart(() => {
+      if (!this._isActiveSession(sessionId, session)) return;
+
+      this._dictation = {
+        status: { type: "running" },
+        inputDisabled,
+        ...(this._dictation?.transcript && {
+          transcript: this._dictation.transcript,
+        }),
+      };
+      this._notifySubscribers();
+    });
+    this._dictationUnsubscribes.push(unsubStart);
+
+    const unsubEnd = session.onSpeechEnd(() => {
+      this._cleanupDictation({ sessionId });
+    });
+    this._dictationUnsubscribes.push(unsubEnd);
+
+    const statusInterval = setInterval(() => {
+      if (!this._isActiveSession(sessionId, session)) return;
+
+      if (session.status.type === "ended") {
+        this._cleanupDictation({ sessionId });
+      }
+    }, 100);
+    this._dictationUnsubscribes.push(() => clearInterval(statusInterval));
+  }
+
+  public stopDictation(): void {
+    if (!this._dictationSession) return;
+
+    const session = this._dictationSession;
+    const sessionId = this._activeDictationSessionId;
+    session.stop().finally(() => {
+      this._cleanupDictation({ sessionId });
+    });
+  }
+
+  private _cleanupDictation(options?: { sessionId: number | undefined }): void {
+    const isStaleSession =
+      options?.sessionId !== undefined &&
+      options.sessionId !== this._activeDictationSessionId;
+    if (isStaleSession || this._isCleaningDictation) return;
+
+    this._isCleaningDictation = true;
+    try {
+      for (const unsub of this._dictationUnsubscribes) {
+        unsub();
+      }
+      this._dictationUnsubscribes = [];
+      this._dictationSession = undefined;
+      this._activeDictationSessionId = undefined;
+      this._dictation = undefined;
+      this._dictationBaseText = "";
+      this._currentInterimText = "";
+      this._notifySubscribers();
+    } finally {
+      this._isCleaningDictation = false;
+    }
+  }
+
   private _eventSubscribers = new Map<
     ComposerRuntimeEventType,
     Set<() => void>

package/src/legacy-runtime/runtime-cores/composer/DefaultEditComposerRuntimeCore.tsx

@@ -1,7 +1,8 @@
-import { AppendMessage, ThreadMessage } from "../../../types";
+import type { AppendMessage, ThreadMessage } from "../../../types";
 import { getThreadMessageText } from "../../../utils/getThreadMessageText";
-import { AttachmentAdapter } from "../adapters/attachment";
-import { ThreadRuntimeCore } from "../core/ThreadRuntimeCore";
+import type { AttachmentAdapter } from "../adapters/attachment";
+import type { DictationAdapter } from "../adapters/speech/SpeechAdapterTypes";
+import type { ThreadRuntimeCore } from "../core/ThreadRuntimeCore";
 import { BaseComposerRuntimeCore } from "./BaseComposerRuntimeCore";
 
 export class DefaultEditComposerRuntimeCore extends BaseComposerRuntimeCore {
@@ -13,13 +14,22 @@ export class DefaultEditComposerRuntimeCore extends BaseComposerRuntimeCore {
     return this.runtime.adapters?.attachments;
   }
 
+  protected getDictationAdapter() {
+    return this.runtime.adapters?.dictation;
+  }
+
   private _nonTextParts;
   private _previousText;
   private _parentId;
   private _sourceId;
   constructor(
     private runtime: ThreadRuntimeCore & {
-      adapters?: { attachments?: AttachmentAdapter | undefined } | undefined;
+      adapters?:
+        | {
+            attachments?: AttachmentAdapter | undefined;
+            dictation?: DictationAdapter | undefined;
+          }
+        | undefined;
     },
     private endEditCallback: () => void,
     { parentId, message }: { parentId: string | null; message: ThreadMessage },

package/src/legacy-runtime/runtime-cores/composer/DefaultThreadComposerRuntimeCore.tsx

@@ -1,7 +1,8 @@
-import { AppendMessage, PendingAttachment } from "../../../types";
-import { AttachmentAdapter } from "../adapters/attachment";
-import { ThreadComposerRuntimeCore } from "../core/ComposerRuntimeCore";
-import { ThreadRuntimeCore } from "../core/ThreadRuntimeCore";
+import type { AppendMessage, PendingAttachment } from "../../../types";
+import type { AttachmentAdapter } from "../adapters/attachment";
+import type { DictationAdapter } from "../adapters/speech/SpeechAdapterTypes";
+import type { ThreadComposerRuntimeCore } from "../core/ComposerRuntimeCore";
+import type { ThreadRuntimeCore } from "../core/ThreadRuntimeCore";
 import { BaseComposerRuntimeCore } from "./BaseComposerRuntimeCore";
 
 export class DefaultThreadComposerRuntimeCore
@@ -21,9 +22,18 @@ export class DefaultThreadComposerRuntimeCore
     return this.runtime.adapters?.attachments;
   }
 
+  protected getDictationAdapter() {
+    return this.runtime.adapters?.dictation;
+  }
+
   constructor(
     private runtime: Omit<ThreadRuntimeCore, "composer"> & {
-      adapters?: { attachments?: AttachmentAdapter | undefined } | undefined;
+      adapters?:
+        | {
+            attachments?: AttachmentAdapter | undefined;
+            dictation?: DictationAdapter | undefined;
+          }
+        | undefined;
     },
   ) {
     super();

package/src/legacy-runtime/runtime-cores/core/ComposerRuntimeCore.tsx

@@ -3,10 +3,31 @@ import type {
   PendingAttachment,
   Unsubscribe,
 } from "../../../types";
-import { MessageRole, RunConfig } from "../../../types/AssistantTypes";
+import type { MessageRole, RunConfig } from "../../../types/AssistantTypes";
+import type { DictationAdapter } from "../adapters/speech/SpeechAdapterTypes";
 
 export type ComposerRuntimeEventType = "send" | "attachment-add";
 
+/**
+ * State representing an active dictation session.
+ */
+export type DictationState = {
+  readonly status: DictationAdapter.Status;
+  /**
+   * The current interim (partial) transcript being recognized.
+   * This is a preview of what the user is saying and may change
+   * as dictation refines its prediction.
+   *
+   * Note: By default, interim transcripts are shown directly in the composer
+   * input field (like native dictation). This property is provided for
+   * advanced customization when you want to display or style the interim
+   * transcript separately.
+   */
+  readonly transcript?: string;
+  /** Whether text input is disabled during this dictation session. */
+  readonly inputDisabled?: boolean;
+};
+
 export type ComposerRuntimeCore = Readonly<{
   isEditing: boolean;
 
@@ -34,6 +55,23 @@ export type ComposerRuntimeCore = Readonly<{
   send: () => void;
   cancel: () => void;
 
+  /**
+   * The current state of dictation.
+   * Undefined when dictation is not active.
+   */
+  dictation: DictationState | undefined;
+
+  /**
+   * Start dictation to convert voice to text input.
+   * Requires a DictationAdapter to be configured.
+   */
+  startDictation: () => void;
+
+  /**
+   * Stop the current dictation session.
+   */
+  stopDictation: () => void;
+
   subscribe: (callback: () => void) => Unsubscribe;
 
   unstable_on: (

package/src/legacy-runtime/runtime-cores/core/ThreadRuntimeCore.tsx

@@ -20,6 +20,7 @@ export type RuntimeCapabilities = {
   readonly cancel: boolean;
   readonly unstable_copy: boolean;
   readonly speech: boolean;
+  readonly dictation: boolean;
   readonly attachments: boolean;
   readonly feedback: boolean;
 };

package/src/legacy-runtime/runtime-cores/core/index.ts

@@ -3,3 +3,5 @@ export type {
   SubmitFeedbackOptions,
   ThreadSuggestion,
 } from "./ThreadRuntimeCore";
+
+export type { DictationState } from "./ComposerRuntimeCore";

package/src/legacy-runtime/runtime-cores/external-store/ExternalStoreAdapter.tsx

@@ -1,15 +1,18 @@
-import { AppendMessage, ThreadMessage } from "../../../types";
-import { AttachmentAdapter } from "../adapters/attachment";
-import {
+import type { AppendMessage, ThreadMessage } from "../../../types";
+import type { AttachmentAdapter } from "../adapters/attachment";
+import type {
   AddToolResultOptions,
   ResumeRunConfig,
   StartRunConfig,
   ThreadSuggestion,
 } from "../core/ThreadRuntimeCore";
-import { FeedbackAdapter } from "../adapters/feedback/FeedbackAdapter";
-import { SpeechSynthesisAdapter } from "../adapters/speech/SpeechAdapterTypes";
-import { ThreadMessageLike } from "./ThreadMessageLike";
-import { ExportedMessageRepository } from "../utils/MessageRepository";
+import type { FeedbackAdapter } from "../adapters/feedback/FeedbackAdapter";
+import type {
+  SpeechSynthesisAdapter,
+  DictationAdapter,
+} from "../adapters/speech/SpeechAdapterTypes";
+import type { ThreadMessageLike } from "./ThreadMessageLike";
+import type { ExportedMessageRepository } from "../utils/MessageRepository";
 import type { ReadonlyJSONValue } from "assistant-stream/utils";
 
 export type ExternalStoreThreadData<TState extends "regular" | "archived"> = {
@@ -85,6 +88,7 @@ type ExternalStoreAdapterBase<T> = {
     | {
         attachments?: AttachmentAdapter | undefined;
         speech?: SpeechSynthesisAdapter | undefined;
+        dictation?: DictationAdapter | undefined;
         feedback?: FeedbackAdapter | undefined;
         /**
          * @deprecated This API is still under active development and might change without notice.

package/src/legacy-runtime/runtime-cores/external-store/ExternalStoreThreadRuntimeCore.tsx

@@ -1,4 +1,4 @@
-import {
+import type {
   AddToolResultOptions,
   ResumeRunConfig,
   ResumeToolCallOptions,
@@ -6,22 +6,25 @@ import {
   ThreadSuggestion,
 } from "../core/ThreadRuntimeCore";
 
-import { AppendMessage, ThreadMessage } from "../../../types";
-import { ExternalStoreAdapter } from "./ExternalStoreAdapter";
+import type { AppendMessage, ThreadMessage } from "../../../types";
+import type { ExternalStoreAdapter } from "./ExternalStoreAdapter";
 import {
   getExternalStoreMessage,
   symbolInnerMessage,
 } from "./getExternalStoreMessage";
 import { ThreadMessageConverter } from "./ThreadMessageConverter";
 import { getAutoStatus, isAutoStatus } from "./auto-status";
-import { fromThreadMessageLike, ThreadMessageLike } from "./ThreadMessageLike";
-import { getThreadMessageText } from "../../../utils/getThreadMessageText";
 import {
+  fromThreadMessageLike,
+  type ThreadMessageLike,
+} from "./ThreadMessageLike";
+import { getThreadMessageText } from "../../../utils/getThreadMessageText";
+import type {
   RuntimeCapabilities,
   ThreadRuntimeCore,
 } from "../core/ThreadRuntimeCore";
 import { BaseThreadRuntimeCore } from "../core/BaseThreadRuntimeCore";
-import { ModelContextProvider } from "../../../model-context";
+import type { ModelContextProvider } from "../../../model-context";
 import {
   ExportedMessageRepository,
   MessageRepository,
@@ -50,6 +53,7 @@ export class ExternalStoreThreadRuntimeCore
     cancel: false,
     unstable_copy: false,
     speech: false,
+    dictation: false,
     attachments: false,
     feedback: false,
   };
@@ -115,6 +119,7 @@ export class ExternalStoreThreadRuntimeCore
       reload: this._store.onReload !== undefined,
       cancel: this._store.onCancel !== undefined,
       speech: this._store.adapters?.speech !== undefined,
+      dictation: this._store.adapters?.dictation !== undefined,
       unstable_copy: this._store.unstable_capabilities?.copy !== false, // default true
       attachments: !!this._store.adapters?.attachments,
       feedback: !!this._store.adapters?.feedback,
@@ -161,7 +166,7 @@ export class ExternalStoreThreadRuntimeCore
         : this._converter.convertMessages(store.messages, (cache, m, idx) => {
             if (!store.convertMessage) return m;
 
-            const isLast = idx === store.messages!.length - 1;
+            const isLast = idx === (store.messages?.length ?? 0) - 1;
             const autoStatus = getAutoStatus(
               isLast,
               isRunning,

package/src/legacy-runtime/runtime-cores/local/LocalRuntimeOptions.tsx

@@ -1,11 +1,14 @@
-import { ThreadHistoryAdapter } from "../adapters/thread-history/ThreadHistoryAdapter";
-import { AttachmentAdapter } from "../adapters/attachment/AttachmentAdapter";
-import { ThreadMessageLike } from "../external-store";
-import { FeedbackAdapter } from "../adapters/feedback/FeedbackAdapter";
-import { SpeechSynthesisAdapter } from "../adapters/speech/SpeechAdapterTypes";
-import { ChatModelAdapter } from "./ChatModelAdapter";
-import { AssistantCloud } from "assistant-cloud";
-import { SuggestionAdapter } from "../adapters";
+import type { ThreadHistoryAdapter } from "../adapters/thread-history/ThreadHistoryAdapter";
+import type { AttachmentAdapter } from "../adapters/attachment/AttachmentAdapter";
+import type { ThreadMessageLike } from "../external-store";
+import type { FeedbackAdapter } from "../adapters/feedback/FeedbackAdapter";
+import type {
+  SpeechSynthesisAdapter,
+  DictationAdapter,
+} from "../adapters/speech/SpeechAdapterTypes";
+import type { ChatModelAdapter } from "./ChatModelAdapter";
+import type { AssistantCloud } from "assistant-cloud";
+import type { SuggestionAdapter } from "../adapters";
 
 export type LocalRuntimeOptionsBase = {
   maxSteps?: number | undefined;
@@ -14,6 +17,7 @@ export type LocalRuntimeOptionsBase = {
     history?: ThreadHistoryAdapter | undefined;
     attachments?: AttachmentAdapter | undefined;
     speech?: SpeechSynthesisAdapter | undefined;
+    dictation?: DictationAdapter | undefined;
     feedback?: FeedbackAdapter | undefined;
     suggestion?: SuggestionAdapter | undefined;
   };

package/src/legacy-runtime/runtime-cores/local/LocalThreadRuntimeCore.tsx

@@ -2,8 +2,8 @@ import { fromThreadMessageLike, generateId } from "../../../internal";
 import type { AppendMessage, ThreadAssistantMessage } from "../../../types";
 import type { ChatModelAdapter, ChatModelRunResult } from "./ChatModelAdapter";
 import { shouldContinue } from "./shouldContinue";
-import { LocalRuntimeOptionsBase } from "./LocalRuntimeOptions";
-import {
+import type { LocalRuntimeOptionsBase } from "./LocalRuntimeOptions";
+import type {
   AddToolResultOptions,
   ResumeToolCallOptions,
   ThreadSuggestion,
@@ -12,8 +12,8 @@ import {
   ResumeRunConfig,
 } from "../core/ThreadRuntimeCore";
 import { BaseThreadRuntimeCore } from "../core/BaseThreadRuntimeCore";
-import { RunConfig } from "../../../types/AssistantTypes";
-import { ModelContextProvider } from "../../../model-context";
+import type { RunConfig } from "../../../types/AssistantTypes";
+import type { ModelContextProvider } from "../../../model-context";
 
 class AbortError extends Error {
   override name = "AbortError";
@@ -37,6 +37,7 @@ export class LocalThreadRuntimeCore
     cancel: true,
     unstable_copy: true,
     speech: false,
+    dictation: false,
     attachments: false,
     feedback: false,
   };
@@ -89,6 +90,12 @@ export class LocalThreadRuntimeCore
       hasUpdates = true;
     }
 
+    const canDictate = options.adapters?.dictation !== undefined;
+    if (this.capabilities.dictation !== canDictate) {
+      this.capabilities.dictation = canDictate;
+      hasUpdates = true;
+    }
+
     const canAttach = options.adapters?.attachments !== undefined;
     if (this.capabilities.attachments !== canAttach) {
       this.capabilities.attachments = canAttach;

package/src/legacy-runtime/runtime-cores/remote-thread-list/EMPTY_THREAD_CORE.tsx

@@ -1,4 +1,4 @@
-import { ThreadRuntimeCore } from "../../../internal";
+import type { ThreadRuntimeCore } from "../../../internal";
 
 const EMPTY_THREAD_ERROR = new Error(
   "This is the empty thread, a placeholder for the main thread. You cannot perform any actions on this thread instance. This error is probably because you tried to call a thread method in your render function. Call the method inside a `useEffect` hook instead.",
@@ -111,6 +111,16 @@ export const EMPTY_THREAD_CORE: ThreadRuntimeCore = {
       // noop
     },
 
+    dictation: undefined,
+
+    startDictation() {
+      throw EMPTY_THREAD_ERROR;
+    },
+
+    stopDictation() {
+      // noop
+    },
+
     subscribe() {
       return () => {};
     },
@@ -138,6 +148,7 @@ export const EMPTY_THREAD_CORE: ThreadRuntimeCore = {
     cancel: false,
     unstable_copy: false,
     speech: false,
+    dictation: false,
     attachments: false,
     feedback: false,
   },

package/src/legacy-runtime/runtime-cores/remote-thread-list/adapter/cloud.tsx

@@ -114,10 +114,20 @@ export const useCloudThreadListAdapter = (
     },
 
     generateTitle: async (threadId, messages) => {
+      // Filter messages to only include content types the title generator understands
+      // (reasoning, source, etc. are not needed for title generation)
+      // TODO serialize these to a more efficient format
+      const filteredMessages = messages.map((msg) => ({
+        ...msg,
+        content: msg.content.filter(
+          (part) => part.type === "text" || part.type === "tool-call",
+        ),
+      }));
+
       return cloud.runs.stream({
         thread_id: threadId,
         assistant_id: "system/thread_title",
-        messages: messages, // TODO serialize these to a more efficient format
+        messages: filteredMessages,
       });
     },
 

package/src/primitives/actionBarMore/ActionBarMoreContent.tsx

@@ -0,0 +1,46 @@
+"use client";
+
+import { ComponentPropsWithoutRef, ComponentRef, forwardRef } from "react";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+import { ScopedProps, useDropdownMenuScope } from "./scope";
+
+export namespace ActionBarMorePrimitiveContent {
+  export type Element = ComponentRef<typeof DropdownMenuPrimitive.Content>;
+  export type Props = ComponentPropsWithoutRef<
+    typeof DropdownMenuPrimitive.Content
+  > & {
+    portalProps?:
+      | ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Portal>
+      | undefined;
+  };
+}
+
+export const ActionBarMorePrimitiveContent = forwardRef<
+  ActionBarMorePrimitiveContent.Element,
+  ActionBarMorePrimitiveContent.Props
+>(
+  (
+    {
+      __scopeActionBarMore,
+      portalProps,
+      sideOffset = 4,
+      ...props
+    }: ScopedProps<ActionBarMorePrimitiveContent.Props>,
+    forwardedRef,
+  ) => {
+    const scope = useDropdownMenuScope(__scopeActionBarMore);
+
+    return (
+      <DropdownMenuPrimitive.Portal {...scope} {...portalProps}>
+        <DropdownMenuPrimitive.Content
+          {...scope}
+          {...props}
+          ref={forwardedRef}
+          sideOffset={sideOffset}
+        />
+      </DropdownMenuPrimitive.Portal>
+    );
+  },
+);
+
+ActionBarMorePrimitiveContent.displayName = "ActionBarMorePrimitive.Content";

package/src/primitives/actionBarMore/ActionBarMoreItem.tsx

@@ -0,0 +1,31 @@
+"use client";
+
+import { ComponentPropsWithoutRef, ComponentRef, forwardRef } from "react";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+import { ScopedProps, useDropdownMenuScope } from "./scope";
+
+export namespace ActionBarMorePrimitiveItem {
+  export type Element = ComponentRef<typeof DropdownMenuPrimitive.Item>;
+  export type Props = ComponentPropsWithoutRef<
+    typeof DropdownMenuPrimitive.Item
+  >;
+}
+
+export const ActionBarMorePrimitiveItem = forwardRef<
+  ActionBarMorePrimitiveItem.Element,
+  ActionBarMorePrimitiveItem.Props
+>(
+  (
+    {
+      __scopeActionBarMore,
+      ...rest
+    }: ScopedProps<ActionBarMorePrimitiveItem.Props>,
+    ref,
+  ) => {
+    const scope = useDropdownMenuScope(__scopeActionBarMore);
+
+    return <DropdownMenuPrimitive.Item {...scope} {...rest} ref={ref} />;
+  },
+);
+
+ActionBarMorePrimitiveItem.displayName = "ActionBarMorePrimitive.Item";