@assistant-ui/react 0.15.16 → 0.15.18

package/src/primitives/composer/ComposerInput.test.tsx

@@ -81,7 +81,8 @@ vi.mock("./trigger/TriggerPopoverRootContext", () => ({
 
 let escapeKeydownHandler: ((event: KeyboardEvent) => void) | null = null;
 
-vi.mock("@radix-ui/react-use-escape-keydown", () => ({
+vi.mock("radix-ui/internal", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("radix-ui/internal")>()),
   useEscapeKeydown: (handler: (event: KeyboardEvent) => void) => {
     escapeKeydownHandler = handler;
   },

package/src/primitives/composer/ComposerInput.tsx

@@ -1,7 +1,7 @@
 "use client";
 
-import { composeEventHandlers } from "@radix-ui/primitive";
-import { useComposedRefs } from "@radix-ui/react-compose-refs";
+import { composeEventHandlers } from "radix-ui/internal";
+import { useComposedRefs } from "radix-ui/internal";
 import { Slot } from "radix-ui";
 import {
   type ClipboardEvent,
@@ -19,7 +19,7 @@ import TextareaAutosize, {
   type TextareaAutosizeProps,
   type TextareaHeightChangeMeta,
 } from "react-textarea-autosize";
-import { useEscapeKeydown } from "@radix-ui/react-use-escape-keydown";
+import { useEscapeKeydown } from "radix-ui/internal";
 import { useOnScrollToBottom } from "../../utils/hooks/useOnScrollToBottom";
 import { useMediaQuery } from "../../utils/hooks/useMediaQuery";
 import { useAui } from "@assistant-ui/store";

package/src/primitives/composer/ComposerInputPluginContext.tsx

@@ -51,16 +51,6 @@ export type ComposerInputPluginRegistry = {
 const ComposerInputPluginRegistryContext =
   createContext<ComposerInputPluginRegistry | null>(null);
 
-export const useComposerInputPluginRegistry =
-  (): ComposerInputPluginRegistry => {
-    const ctx = useContext(ComposerInputPluginRegistryContext);
-    if (!ctx)
-      throw new Error(
-        "useComposerInputPluginRegistry must be used within a ComposerInputPluginProvider",
-      );
-    return ctx;
-  };
-
 export const useComposerInputPluginRegistryOptional =
   (): ComposerInputPluginRegistry | null => {
     return useContext(ComposerInputPluginRegistryContext);

package/src/primitives/composer/ComposerQuote.tsx

@@ -8,7 +8,7 @@ import {
   useCallback,
 } from "react";
 import { useAui, useAuiState } from "@assistant-ui/store";
-import { composeEventHandlers } from "@radix-ui/primitive";
+import { composeEventHandlers } from "radix-ui/internal";
 
 // ---- Root ----
 

package/src/primitives/composer/ComposerRoot.tsx

@@ -1,6 +1,6 @@
 "use client";
 
-import { composeEventHandlers } from "@radix-ui/primitive";
+import { composeEventHandlers } from "radix-ui/internal";
 import { useAuiState } from "@assistant-ui/store";
 import { Primitive } from "../../utils/Primitive";
 import {

package/src/primitives/composer/trigger/TriggerPopover.tsx

@@ -28,6 +28,7 @@ import {
   useTriggerPopoverAriaPublish,
   useTriggerPopoverRootContext,
 } from "./TriggerPopoverRootContext";
+import type { TriggerMatcher } from "./detectTrigger";
 
 const TriggerPopoverScopeContext =
   createContext<TriggerPopoverResourceOutput | null>(null);
@@ -70,6 +71,8 @@ export namespace ComposerPrimitiveTriggerPopover {
   > & {
     /** The character(s) that activate this trigger (e.g. `"@"`, `"/"`). Also serves as the trigger identity within the root. */
     readonly char: string;
+    /** Overrides trigger detection for both textarea and Lexical inputs. `endOffset` is the exclusive replace bound. */
+    readonly matcher?: TriggerMatcher | undefined;
     /** Adapter providing categories and items. */
     readonly adapter?: Unstable_TriggerAdapter | undefined;
     /** Whether the adapter is resolving items, surfaced to the popover scope for async sources. @default false */
@@ -111,6 +114,7 @@ export const ComposerPrimitiveTriggerPopover = forwardRef<
   (
     {
       char,
+      matcher,
       adapter,
       isLoading = false,
       "aria-label": ariaLabel,
@@ -122,6 +126,15 @@ export const ComposerPrimitiveTriggerPopover = forwardRef<
     const aui = useAui();
     const text = useAuiState((s) => s.composer.text);
     const popoverId = useId();
+    const matcherRef = useRef(matcher);
+    useEffect(() => {
+      matcherRef.current = matcher;
+    });
+    const [registeredMatcher] = useState(
+      () => (nextText: string, triggerChar: string, cursorPosition: number) =>
+        matcherRef.current!(nextText, triggerChar, cursorPosition),
+    );
+    const hasMatcher = matcher !== undefined;
 
     // Track in state (for resource reactivity) + ref (dev warning on duplicate registrations).
     const behaviorRef = useRef<TriggerBehavior | null>(null);
@@ -165,6 +178,7 @@ export const ComposerPrimitiveTriggerPopover = forwardRef<
         adapter,
         text,
         triggerChar: char,
+        matcher,
         behavior: behavior ?? undefined,
         aui,
         popoverId,
@@ -178,10 +192,11 @@ export const ComposerPrimitiveTriggerPopover = forwardRef<
     useEffect(() => {
       return root.register({
         char,
+        ...(hasMatcher ? { matcher: registeredMatcher } : {}),
         ...(behavior ? { behavior } : {}),
         resource: getResource(),
       });
-    }, [root, char, behavior]);
+    }, [root, char, hasMatcher, behavior]);
 
     const pluginRegistry = useComposerInputPluginRegistryOptional();
     useEffect(() => {

package/src/primitives/composer/trigger/TriggerPopoverAction.tsx

@@ -5,7 +5,7 @@ import type {
   Unstable_TriggerItem,
 } from "@assistant-ui/core";
 import { unstable_defaultDirectiveFormatter } from "@assistant-ui/core";
-import { useEffect, useRef, type FC } from "react";
+import { useEffect, useInsertionEffect, useRef, type FC } from "react";
 import { useTriggerBehaviorRegistration } from "./TriggerPopover";
 import type { TriggerBehavior } from "./triggerSelectionResource";
 
@@ -42,7 +42,9 @@ export const ComposerPrimitiveTriggerPopoverAction: FC<
 > = ({ formatter, onExecute, removeOnExecute }) => {
   const { register } = useTriggerBehaviorRegistration();
   const onExecuteRef = useRef(onExecute);
-  onExecuteRef.current = onExecute;
+  useInsertionEffect(() => {
+    onExecuteRef.current = onExecute;
+  }, [onExecute]);
 
   useEffect(() => {
     const behavior: TriggerBehavior = {

package/src/primitives/composer/trigger/TriggerPopoverBack.tsx

@@ -6,7 +6,7 @@ import {
   type ComponentPropsWithoutRef,
   forwardRef,
 } from "react";
-import { composeEventHandlers } from "@radix-ui/primitive";
+import { composeEventHandlers } from "radix-ui/internal";
 import { useTriggerPopoverScopeContext } from "./TriggerPopover";
 
 export namespace ComposerPrimitiveTriggerPopoverBack {

package/src/primitives/composer/trigger/TriggerPopoverBehavior.test.tsx

@@ -0,0 +1,109 @@
+// @vitest-environment jsdom
+
+import { Suspense, type ReactNode } from "react";
+import { render, waitFor } from "@testing-library/react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { Unstable_TriggerItem } from "@assistant-ui/core";
+import type { TriggerBehavior } from "./triggerSelectionResource";
+
+const mocks = vi.hoisted(() => ({ register: vi.fn() }));
+
+vi.mock("./TriggerPopover", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("./TriggerPopover")>()),
+  useTriggerBehaviorRegistration: () => ({ register: mocks.register }),
+}));
+
+import { ComposerPrimitiveTriggerPopoverAction } from "./TriggerPopoverAction";
+import { ComposerPrimitiveTriggerPopoverDirective } from "./TriggerPopoverDirective";
+
+const item: Unstable_TriggerItem = {
+  id: "item-1",
+  type: "test",
+  label: "Item",
+};
+
+const verifyCommittedCallback = async (
+  renderBehavior: (callback: (item: Unstable_TriggerItem) => void) => ReactNode,
+  invoke: (behavior: TriggerBehavior) => void,
+) => {
+  let behavior: TriggerBehavior | undefined;
+  mocks.register.mockImplementation((next: TriggerBehavior) => {
+    behavior = next;
+    return () => {};
+  });
+
+  let suspend = false;
+  const suspended = new Promise<never>(() => {});
+  const renderProbe = vi.fn();
+  const Suspender = () => {
+    if (suspend) throw suspended;
+    return null;
+  };
+  const Probe = () => {
+    renderProbe();
+    return null;
+  };
+  const View = ({
+    callback,
+  }: {
+    callback: (item: Unstable_TriggerItem) => void;
+  }) => (
+    <Suspense fallback={null}>
+      {renderBehavior(callback)}
+      <Probe />
+      <Suspender />
+    </Suspense>
+  );
+
+  const committed = vi.fn();
+  const abandoned = vi.fn();
+  const view = render(<View callback={committed} />);
+
+  await waitFor(() => expect(behavior).toBeDefined());
+  renderProbe.mockClear();
+
+  suspend = true;
+  view.rerender(<View callback={abandoned} />);
+  await waitFor(() => expect(renderProbe).toHaveBeenCalled());
+
+  invoke(behavior!);
+  expect(committed).toHaveBeenCalledExactlyOnceWith(item);
+  expect(abandoned).not.toHaveBeenCalled();
+
+  suspend = false;
+  view.rerender(<View callback={abandoned} />);
+  invoke(behavior!);
+  expect(abandoned).toHaveBeenCalledExactlyOnceWith(item);
+};
+
+describe("TriggerPopover behavior callbacks", () => {
+  beforeEach(() => {
+    mocks.register.mockReset();
+  });
+
+  it("keeps the committed action callback during abandoned renders", async () => {
+    await verifyCommittedCallback(
+      (onExecute) => (
+        <ComposerPrimitiveTriggerPopoverAction onExecute={onExecute} />
+      ),
+      (behavior) => {
+        if (behavior.kind !== "action") throw new Error("Expected action");
+        behavior.onExecute(item);
+      },
+    );
+  });
+
+  it("keeps the committed directive callback during abandoned renders", async () => {
+    await verifyCommittedCallback(
+      (onInserted) => (
+        <ComposerPrimitiveTriggerPopoverDirective onInserted={onInserted} />
+      ),
+      (behavior) => {
+        if (behavior.kind !== "directive") {
+          throw new Error("Expected directive");
+        }
+        behavior.onInserted?.(item);
+      },
+    );
+  });
+});

package/src/primitives/composer/trigger/TriggerPopoverCategories.tsx

@@ -8,7 +8,7 @@ import {
   forwardRef,
   useCallback,
 } from "react";
-import { composeEventHandlers } from "@radix-ui/primitive";
+import { composeEventHandlers } from "radix-ui/internal";
 import { useTriggerPopoverScopeContext } from "./TriggerPopover";
 import type { Unstable_TriggerCategory } from "@assistant-ui/core";
 

package/src/primitives/composer/trigger/TriggerPopoverDirective.tsx

@@ -5,7 +5,7 @@ import type {
   Unstable_TriggerItem,
 } from "@assistant-ui/core";
 import { unstable_defaultDirectiveFormatter } from "@assistant-ui/core";
-import { useEffect, useRef, type FC } from "react";
+import { useEffect, useInsertionEffect, useRef, type FC } from "react";
 import { useTriggerBehaviorRegistration } from "./TriggerPopover";
 import type { TriggerBehavior } from "./triggerSelectionResource";
 
@@ -39,7 +39,9 @@ export const ComposerPrimitiveTriggerPopoverDirective: FC<
 > = ({ formatter, onInserted }) => {
   const { register } = useTriggerBehaviorRegistration();
   const onInsertedRef = useRef(onInserted);
-  onInsertedRef.current = onInserted;
+  useInsertionEffect(() => {
+    onInsertedRef.current = onInserted;
+  }, [onInserted]);
 
   useEffect(() => {
     const behavior: TriggerBehavior = {

package/src/primitives/composer/trigger/TriggerPopoverItems.tsx

@@ -8,7 +8,7 @@ import {
   forwardRef,
   useCallback,
 } from "react";
-import { composeEventHandlers } from "@radix-ui/primitive";
+import { composeEventHandlers } from "radix-ui/internal";
 import { useTriggerPopoverScopeContext } from "./TriggerPopover";
 import type { Unstable_TriggerItem } from "@assistant-ui/core";
 

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

@@ -14,6 +14,7 @@ import {
   type SelectItemOverride,
   type TriggerBehavior,
 } from "./triggerSelectionResource";
+import type { TriggerMatcher } from "./detectTrigger";
 
 export type { SelectItemOverride, TriggerBehavior };
 export type { TriggerPopoverKeyEvent } from "./triggerKeyboardResource";
@@ -57,6 +58,7 @@ const useTriggerPopoverResource = ({
   adapter,
   text,
   triggerChar,
+  matcher,
   behavior,
   aui,
   popoverId,
@@ -65,6 +67,7 @@ const useTriggerPopoverResource = ({
   adapter: Unstable_TriggerAdapter | undefined;
   text: string;
   triggerChar: string;
+  matcher: TriggerMatcher | undefined;
   behavior: TriggerBehavior | undefined;
   aui: AssistantClient;
   /** Stable ID for accessible element IDs (pass React's useId() from component layer). */
@@ -72,7 +75,7 @@ const useTriggerPopoverResource = ({
   isLoading: boolean;
 }): TriggerPopoverResourceOutput => {
   const detection = useResource(
-    TriggerDetectionResource({ text, triggerChar }),
+    TriggerDetectionResource({ text, triggerChar, matcher }),
   );
 
   const open =

package/src/primitives/composer/trigger/TriggerPopoverRootContext.tsx

@@ -16,9 +16,11 @@ import {
 } from "../ComposerInputPluginContext";
 import type { TriggerPopoverResourceOutput } from "./TriggerPopoverResource";
 import type { TriggerBehavior } from "./triggerSelectionResource";
+import type { TriggerMatcher } from "./detectTrigger";
 
 export type RegisteredTrigger = {
   readonly char: string;
+  readonly matcher?: TriggerMatcher | undefined;
   /** Behavior contributed by a child `TriggerPopover.Directive` / `.Action`. */
   readonly behavior?: TriggerBehavior;
   readonly resource: TriggerPopoverResourceOutput;

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

@@ -1,11 +1,27 @@
 import { describe, it, expect } from "vitest";
-import { detectTrigger } from "./detectTrigger";
+import { detectTrigger, type TriggerMatcher } from "./detectTrigger";
+
+const matchFromLastTrigger: TriggerMatcher = (
+  text,
+  triggerChar,
+  cursorPosition,
+) => {
+  const textUpToCursor = text.slice(0, cursorPosition);
+  const offset = textUpToCursor.lastIndexOf(triggerChar);
+  if (offset === -1) return null;
+  return {
+    query: textUpToCursor.slice(offset + triggerChar.length),
+    offset,
+    endOffset: cursorPosition,
+  };
+};
 
 describe("detectTrigger", () => {
   it("detects @query at cursor position", () => {
     expect(detectTrigger("hello @wea", "@", 10)).toEqual({
       query: "wea",
       offset: 6,
+      endOffset: 10,
     });
   });
 
@@ -25,14 +41,76 @@ describe("detectTrigger", () => {
     expect(detectTrigger("@foo", "@", 4)).toEqual({
       query: "foo",
       offset: 0,
+      endOffset: 4,
     });
   });
 
   it("stops at whitespace in query", () => {
-    // "@foo bar" — space terminates the mention
     expect(detectTrigger("@foo bar", "@", 8)).toBeNull();
   });
 
+  it("uses a custom matcher for multi-word queries", () => {
+    expect(
+      detectTrigger("hello @Example UK", "@", 17, matchFromLastTrigger),
+    ).toEqual({
+      query: "Example UK",
+      offset: 6,
+      endOffset: 17,
+    });
+  });
+
+  it("keeps a matcher endOffset that is not the query length", () => {
+    const matchNormalized: TriggerMatcher = (
+      text,
+      triggerChar,
+      cursorPosition,
+    ) => {
+      const textUpToCursor = text.slice(0, cursorPosition);
+      const offset = textUpToCursor.lastIndexOf(triggerChar);
+      if (offset === -1) return null;
+      return {
+        query: "example",
+        offset,
+        endOffset: cursorPosition,
+      };
+    };
+
+    expect(
+      detectTrigger("hello @Example UK", "@", 17, matchNormalized),
+    ).toEqual({
+      query: "example",
+      offset: 6,
+      endOffset: 17,
+    });
+  });
+
+  it("rejects a matcher whose offset is not the trigger", () => {
+    const match: TriggerMatcher = () => ({
+      query: "x",
+      offset: 0,
+      endOffset: 2,
+    });
+    expect(detectTrigger("hello @x", "@", 8, match)).toBeNull();
+  });
+
+  it("rejects a matcher that matches at the caret", () => {
+    const match: TriggerMatcher = () => ({
+      query: "",
+      offset: 6,
+      endOffset: 7,
+    });
+    expect(detectTrigger("hello @foo", "@", 6, match)).toBeNull();
+  });
+
+  it("rejects a matcher whose endOffset is inside the trigger", () => {
+    const match: TriggerMatcher = () => ({
+      query: "",
+      offset: 6,
+      endOffset: 6,
+    });
+    expect(detectTrigger("hello @foo", "@", 10, match)).toBeNull();
+  });
+
   it("stops at newline", () => {
     expect(detectTrigger("@foo\nbar", "@", 8)).toBeNull();
   });
@@ -45,20 +123,19 @@ describe("detectTrigger", () => {
     expect(detectTrigger("hello\t@foo", "@", 10)).toEqual({
       query: "foo",
       offset: 6,
+      endOffset: 10,
     });
   });
 
   it("finds trigger closest to cursor, not earlier ones", () => {
-    // Text has two @: "hello @old text @new"
-    // Cursor at end → should find @new
     expect(detectTrigger("hello @old text @new", "@", 20)).toEqual({
       query: "new",
       offset: 16,
+      endOffset: 20,
     });
   });
 
   it("ignores trigger after cursor", () => {
-    // Cursor at position 5, trigger at position 10
     expect(detectTrigger("hello text @foo", "@", 5)).toBeNull();
   });
 
@@ -66,6 +143,7 @@ describe("detectTrigger", () => {
     expect(detectTrigger("hello @@foo", "@@", 11)).toEqual({
       query: "foo",
       offset: 6,
+      endOffset: 11,
     });
   });
 
@@ -73,6 +151,7 @@ describe("detectTrigger", () => {
     expect(detectTrigger("hello @", "@", 7)).toEqual({
       query: "",
       offset: 6,
+      endOffset: 7,
     });
   });
 
@@ -80,6 +159,7 @@ describe("detectTrigger", () => {
     expect(detectTrigger("全角\u3000@foo", "@", 7)).toEqual({
       query: "foo",
       offset: 3,
+      endOffset: 7,
     });
   });
 
@@ -87,6 +167,7 @@ describe("detectTrigger", () => {
     expect(detectTrigger("x\u00A0@foo", "@", 6)).toEqual({
       query: "foo",
       offset: 2,
+      endOffset: 6,
     });
   });
 
@@ -98,6 +179,7 @@ describe("detectTrigger", () => {
     expect(detectTrigger("hello\u3000@foo", "@", 10)).toEqual({
       query: "foo",
       offset: 6,
+      endOffset: 10,
     });
   });
 
@@ -105,6 +187,7 @@ describe("detectTrigger", () => {
     expect(detectTrigger("hello\u00a0@foo", "@", 10)).toEqual({
       query: "foo",
       offset: 6,
+      endOffset: 10,
     });
   });
 

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

@@ -1,5 +1,43 @@
 const WHITESPACE_RE = /\s/u;
 
+export type TriggerMatch = {
+  readonly query: string;
+  readonly offset: number;
+  readonly endOffset: number;
+};
+
+/**
+ * Locates a trigger query in `text` relative to `cursorPosition`.
+ *
+ * `offset` is the index of `triggerChar`. `endOffset` is the exclusive end of
+ * the span both the textarea and Lexical replace on select. `query` is the
+ * search string and may differ from that span.
+ *
+ * Return null when the caret is at or before the trigger. Escape moves the
+ * caret to `offset` so a match there would reopen the popover.
+ */
+export type TriggerMatcher = (
+  text: string,
+  triggerChar: string,
+  cursorPosition: number,
+) => TriggerMatch | null;
+
+export function resolveTriggerMatch(
+  text: string,
+  triggerChar: string,
+  cursorPosition: number,
+  match: TriggerMatch | null,
+): TriggerMatch | null {
+  if (match === null) return null;
+  const { query, offset, endOffset } = match;
+  if (offset < 0 || offset + triggerChar.length > cursorPosition) return null;
+  if (!text.startsWith(triggerChar, offset)) return null;
+  if (endOffset < offset + triggerChar.length || endOffset > text.length) {
+    return null;
+  }
+  return { query, offset, endOffset };
+}
+
 /**
  * Detect a trigger character in text relative to the cursor position.
  *
@@ -9,27 +47,30 @@ export function detectTrigger(
   text: string,
   triggerChar: string,
   cursorPosition: number,
-): {
-  query: string;
-  offset: number;
-} | null {
-  // Only consider text up to the cursor
+  matcher?: TriggerMatcher | undefined,
+): TriggerMatch | null {
+  if (matcher) {
+    return resolveTriggerMatch(
+      text,
+      triggerChar,
+      cursorPosition,
+      matcher(text, triggerChar, cursorPosition),
+    );
+  }
+
   const textUpToCursor = text.slice(0, cursorPosition);
 
-  // Search backwards from cursor for the trigger character.
-  // Stop at any whitespace during scan — trigger must be contiguous with cursor.
   for (let i = textUpToCursor.length - 1; i >= 0; i--) {
     const char = textUpToCursor[i]!;
 
     if (WHITESPACE_RE.test(char)) return null;
 
     if (textUpToCursor.startsWith(triggerChar, i)) {
-      // Trigger must be preceded by whitespace or be at start of text
       if (i > 0 && !WHITESPACE_RE.test(textUpToCursor[i - 1]!)) continue;
 
       const query = textUpToCursor.slice(i + triggerChar.length);
 
-      return { query, offset: i };
+      return { query, offset: i, endOffset: cursorPosition };
     }
   }
 

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

@@ -21,6 +21,7 @@ export {
 } from "./TriggerPopoverItems";
 export { ComposerPrimitiveTriggerPopoverBack } from "./TriggerPopoverBack";
 export type { TriggerBehavior } from "./triggerSelectionResource";
+export type { TriggerMatch, TriggerMatcher } from "./detectTrigger";
 
 import { ComposerPrimitiveTriggerPopover as Base } from "./TriggerPopover";
 import { ComposerPrimitiveTriggerPopoverAction } from "./TriggerPopoverAction";

package/src/primitives/composer/trigger/matchesTriggerItemQuery.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect } from "vitest";
+import { matchesTriggerItemQuery } from "./matchesTriggerItemQuery";
+import type { Unstable_TriggerItem } from "@assistant-ui/core";
+
+const item = (
+  overrides: Partial<Unstable_TriggerItem>,
+): Unstable_TriggerItem => ({
+  id: "summarize",
+  type: "command",
+  label: "Summarize",
+  ...overrides,
+});
+
+describe("matchesTriggerItemQuery", () => {
+  it("matches every item on an empty query", () => {
+    expect(matchesTriggerItemQuery(item({}), "")).toBe(true);
+  });
+
+  it("matches case-insensitively against the id", () => {
+    expect(
+      matchesTriggerItemQuery(item({ id: "SummArize", label: "y" }), "marize"),
+    ).toBe(true);
+  });
+
+  it("matches case-insensitively against the label", () => {
+    expect(
+      matchesTriggerItemQuery(
+        item({ id: "x", label: "Translate Text" }),
+        "late",
+      ),
+    ).toBe(true);
+  });
+
+  it("matches against the description when present", () => {
+    expect(
+      matchesTriggerItemQuery(
+        item({ id: "x", label: "y", description: "Condense the thread" }),
+        "condense",
+      ),
+    ).toBe(true);
+  });
+
+  it("does not match when no field contains the query", () => {
+    expect(
+      matchesTriggerItemQuery(item({ description: "nothing here" }), "zzz"),
+    ).toBe(false);
+  });
+
+  it("does not throw on items without a description", () => {
+    expect(matchesTriggerItemQuery(item({}), "zzz")).toBe(false);
+  });
+});