@astryxdesign/core 0.7.0-canary.fe57f54 → 0.7.0

package/src/PowerSearch/PowerSearchEditPopover.test.tsx

@@ -826,3 +826,287 @@ describe('value save', () => {
     });
   });
 });
+
+describe('empty-operator save', () => {
+  const emptyConfig: PowerSearchConfig = {
+    name: 'test-empty',
+    fields: [
+      {
+        key: 'title',
+        label: 'Title',
+        operators: [
+          {key: 'contains', label: 'contains', value: {type: 'string'}},
+          {key: 'is_empty', label: 'is empty', value: {type: 'empty'}},
+        ],
+      },
+      {
+        key: 'assignee',
+        label: 'Assignee',
+        defaultOperator: 'is_unset',
+        operators: [
+          {key: 'is_unset', label: 'is unset', value: {type: 'empty'}},
+          {key: 'is', label: 'is', value: {type: 'string'}},
+        ],
+      },
+    ],
+  };
+
+  type HarnessProps = {
+    filter: React.ComponentProps<typeof PowerSearchEditPopover>['filter'];
+    onSave: (filter: PowerSearchFilter | null) => void;
+  };
+
+  // A parent that keeps the editor mounted and re-renders with a fresh
+  // onSave identity on every render, as an un-memoized consumer does.
+  function Harness({filter, onSave}: HarnessProps) {
+    const config = useInternalConfig(emptyConfig);
+    const [, setTick] = useState(0);
+    return (
+      <>
+        <button type="button" onClick={() => setTick(n => n + 1)}>
+          Rerender
+        </button>
+        <PowerSearchEditPopover
+          config={config}
+          filter={filter}
+          mode="edit"
+          onSave={saved => onSave(saved)}
+          onCancel={() => {}}
+        />
+      </>
+    );
+  }
+
+  // The save is queued as a microtask after the choice; flush it.
+  const selectOption = async (comboboxName: string, optionName: string) => {
+    fireEvent.click(screen.getByRole('combobox', {name: comboboxName}));
+    fireEvent.click(
+      screen.getByRole('option', {name: optionName, hidden: true}),
+    );
+    await act(async () => {});
+  };
+
+  it('saves exactly once when an empty operator is chosen', async () => {
+    const onSave = vi.fn();
+    render(
+      <React.StrictMode>
+        <Harness
+          filter={{field: 'title', operator: 'contains', value: undefined}}
+          onSave={onSave}
+        />
+      </React.StrictMode>,
+    );
+    expect(onSave).not.toHaveBeenCalled();
+
+    await selectOption('Operator', 'is empty');
+    fireEvent.click(screen.getByRole('button', {name: 'Rerender'}));
+    fireEvent.click(screen.getByRole('button', {name: 'Rerender'}));
+
+    expect(onSave).toHaveBeenCalledTimes(1);
+    expect(onSave).toHaveBeenCalledWith({
+      field: 'title',
+      operator: 'is_empty',
+      value: {type: 'empty'},
+    });
+  });
+
+  it('saves exactly once when the field switches to one whose default operator is empty', async () => {
+    const onSave = vi.fn();
+    render(
+      <React.StrictMode>
+        <Harness
+          filter={{field: 'title', operator: 'contains', value: undefined}}
+          onSave={onSave}
+        />
+      </React.StrictMode>,
+    );
+
+    await selectOption('Field', 'Assignee');
+    fireEvent.click(screen.getByRole('button', {name: 'Rerender'}));
+
+    expect(onSave).toHaveBeenCalledTimes(1);
+    expect(onSave).toHaveBeenCalledWith({
+      field: 'assignee',
+      operator: 'is_unset',
+      value: {type: 'empty'},
+    });
+  });
+
+  it('does not save again when the current empty operator or field is re-chosen', async () => {
+    const onSave = vi.fn();
+    render(
+      <React.StrictMode>
+        <Harness
+          filter={{field: 'title', operator: 'contains', value: undefined}}
+          onSave={onSave}
+        />
+      </React.StrictMode>,
+    );
+
+    await selectOption('Operator', 'is empty');
+    expect(onSave).toHaveBeenCalledTimes(1);
+    await selectOption('Operator', 'is empty');
+    expect(onSave).toHaveBeenCalledTimes(1);
+
+    await selectOption('Field', 'Assignee');
+    expect(onSave).toHaveBeenCalledTimes(2);
+    await selectOption('Field', 'Assignee');
+    expect(onSave).toHaveBeenCalledTimes(2);
+  });
+
+  it('does not save just because it opens on a complete empty-operator filter', async () => {
+    const onSave = vi.fn();
+    render(
+      <React.StrictMode>
+        <Harness
+          filter={{field: 'title', operator: 'is_empty', value: undefined}}
+          onSave={onSave}
+        />
+      </React.StrictMode>,
+    );
+    fireEvent.click(screen.getByRole('button', {name: 'Rerender'}));
+    await act(async () => {});
+
+    expect(onSave).not.toHaveBeenCalled();
+  });
+});
+
+describe('empty-operator choices inside PowerSearch', () => {
+  const emptyConfig: PowerSearchConfig = {
+    name: 'test-empty-ps',
+    fields: [
+      {
+        key: 'title',
+        label: 'Title',
+        operators: [
+          {key: 'contains', label: 'contains', value: {type: 'string'}},
+          {key: 'is_empty', label: 'is empty', value: {type: 'empty'}},
+        ],
+      },
+    ],
+  };
+
+  function Harness({
+    initial,
+    onChange,
+  }: {
+    initial: PowerSearchFilter[];
+    onChange: (
+      filters: ReadonlyArray<PowerSearchFilter>,
+      type: string,
+      index: number,
+    ) => void;
+  }) {
+    const [filters, setFilters] = useState(initial);
+    return (
+      <PowerSearch
+        config={emptyConfig}
+        filters={filters}
+        onChange={(next, type, index) => {
+          onChange(next, type, index);
+          setFilters([...next]);
+        }}
+      />
+    );
+  }
+
+  it('returns focus to the search input after an empty operator is chosen', async () => {
+    const onChange = vi.fn();
+    render(
+      <Harness
+        initial={[
+          {
+            field: 'title',
+            operator: 'contains',
+            value: {type: 'string', value: 'x'},
+          },
+        ]}
+        onChange={onChange}
+      />,
+    );
+    act(() => {
+      fireEvent.click(screen.getByText('Title: contains'));
+      flushRAF();
+    });
+    fireEvent.click(
+      screen.getByRole('combobox', {name: 'Operator', hidden: true}),
+    );
+    fireEvent.click(
+      screen.getByRole('option', {name: 'is empty', hidden: true}),
+    );
+    await act(async () => {});
+    act(() => flushRAF());
+
+    expect(onChange).toHaveBeenCalledTimes(1);
+    expect(onChange.mock.calls[0][1]).toBe('edit');
+    expect(document.activeElement).not.toBe(document.body);
+    expect(screen.getAllByRole('combobox')[0]).toHaveFocus();
+  });
+
+  it('commits a clicked empty-operator token once without opening the editor', () => {
+    const onChange = vi.fn();
+    const {container} = render(
+      <Harness
+        initial={[
+          {field: 'title', operator: 'is_empty', value: {type: 'empty'}},
+        ]}
+        onChange={onChange}
+      />,
+    );
+    act(() => {
+      fireEvent.click(screen.getByText(/Title: is empty/));
+      flushRAF();
+    });
+
+    expect(onChange).toHaveBeenCalledTimes(1);
+    expect(onChange).toHaveBeenCalledWith(
+      [{field: 'title', operator: 'is_empty', value: {type: 'empty'}}],
+      'edit',
+      0,
+    );
+    expect(getEditPopoverText(container)).toBe('');
+  });
+});
+
+describe('empty-operator token with an Editor override', () => {
+  it('opens the consumer empty Editor instead of committing', () => {
+    const onChange = vi.fn();
+    const EmptyEditor = ({onCancel}: {onCancel: () => void}) => (
+      <div data-testid="custom-empty-editor">
+        <button type="button" onClick={onCancel}>
+          Close custom
+        </button>
+      </div>
+    );
+    const overrideConfig: PowerSearchConfig = {
+      name: 'test-empty-override',
+      fields: [
+        {
+          key: 'title',
+          label: 'Title',
+          operators: [
+            {key: 'contains', label: 'contains', value: {type: 'string'}},
+            {key: 'is_empty', label: 'is empty', value: {type: 'empty'}},
+          ],
+        },
+      ],
+    };
+    render(
+      <PowerSearch
+        config={overrideConfig}
+        filters={[
+          {field: 'title', operator: 'is_empty', value: {type: 'empty'}},
+        ]}
+        onChange={onChange}
+        components={{empty: {Editor: EmptyEditor}}}
+      />,
+    );
+    act(() => {
+      fireEvent.click(screen.getByText(/Title: is empty/));
+      flushRAF();
+    });
+
+    expect(screen.getByTestId('custom-empty-editor')).toBeInTheDocument();
+    expect(onChange).not.toHaveBeenCalled();
+  });
+});

package/src/PowerSearch/PowerSearchEditPopover.tsx

@@ -33,6 +33,7 @@ import type {
   PartialFilter,
   FilterValue,
   OperatorValue,
+  PowerSearchOperator,
 } from './types';
 
 // Below the popover layer's 400px floor (see popoverLayerStyles in
@@ -689,6 +690,26 @@ export function PowerSearchEditPopover({
     }));
   }, [config, partialFilter.field, t]);
 
+  // An "empty" operator takes no value, so choosing one completes the filter:
+  // save it from the choice itself, once, rather than reacting to the state.
+  // The save is queued as a microtask so it runs after the Selector reporting
+  // the choice has finished closing and refocusing its trigger; a parent that
+  // closes the editor on save can then move focus without the Selector taking
+  // it back onto a node that is about to unmount.
+  const saveIfEmptyOperator = useCallback(
+    (fieldKey: string, operator: PowerSearchOperator | undefined) => {
+      if (fieldKey && operator?.value.type === 'empty') {
+        const filter: PowerSearchFilter = {
+          field: fieldKey,
+          operator: operator.key,
+          value: {type: 'empty'},
+        };
+        queueMicrotask(() => onSave(filter));
+      }
+    },
+    [onSave],
+  );
+
   const handleFieldChange = useCallback(
     (fieldKey: string) => {
       const defaultOp = config.getDefaultOperator(fieldKey);
@@ -697,8 +718,16 @@ export function PowerSearchEditPopover({
         operator: defaultOp?.key,
         value: undefined,
       });
+      // Re-choosing the current field with its current operator changes
+      // nothing, so it saves nothing.
+      if (
+        fieldKey !== partialFilter.field ||
+        defaultOp?.key !== partialFilter.operator
+      ) {
+        saveIfEmptyOperator(fieldKey, defaultOp);
+      }
     },
-    [config],
+    [config, partialFilter.field, partialFilter.operator, saveIfEmptyOperator],
   );
 
   const handleOperatorChange = useCallback(
@@ -712,8 +741,18 @@ export function PowerSearchEditPopover({
         operator: operatorKey,
         value: keepValue ? prev.value : undefined,
       }));
+      // Re-choosing the current operator changes nothing, so it saves nothing.
+      if (operatorKey !== partialFilter.operator) {
+        saveIfEmptyOperator(partialFilter.field, newOp);
+      }
     },
-    [config, partialFilter.field, currentOperator],
+    [
+      config,
+      partialFilter.field,
+      partialFilter.operator,
+      currentOperator,
+      saveIfEmptyOperator,
+    ],
   );
 
   const handleValueChange = useCallback(
@@ -769,17 +808,6 @@ export function PowerSearchEditPopover({
   const isEmptyType = operatorValue?.type === 'empty';
   const isNestedType = operatorValue?.type === 'nested';
 
-  // For empty type, auto-save on mount
-  useEffect(() => {
-    if (isEmptyType && partialFilter.field && partialFilter.operator) {
-      onSave({
-        field: partialFilter.field,
-        operator: partialFilter.operator,
-        value: {type: 'empty'},
-      });
-    }
-  }, [isEmptyType, partialFilter.field, partialFilter.operator, onSave]);
-
   const showOperatorSelector = operatorOptions.length > 1 || !isEmptyType;
 
   // Nested filter editing

package/src/Table/plugins/rowExpansion/useTableRowExpansion.test.tsx

@@ -6,7 +6,6 @@ import {useState} from 'react';
 import {Table} from '../../Table';
 import type {TableColumn} from '../../types';
 import {useTableRowExpansion} from './useTableRowExpansion';
-import {spacingDefaults} from '../../../theme/tokens.stylex';
 import {InternationalizationProvider} from '../../../i18n';
 
 // popover mock for context-menu tests
@@ -236,25 +235,50 @@ describe('useTableRowExpansion (detail panel)', () => {
     // content does: the chevron column's width plus a cell's own padding.
     render(<Harness initialExpanded={new Set(['a'])} />);
     expect(screen.getByTestId('panel').closest('td')).toHaveStyle({
-      paddingInlineStart: 'calc(var(--spacing-10) + var(--spacing-3))',
+      paddingInlineStart: 'calc(40px + var(--spacing-3))',
     });
   });
 
   it('tracks the table density it is rendered at', () => {
     render(<Harness initialExpanded={new Set(['a'])} density="spacious" />);
     expect(screen.getByTestId('panel').closest('td')).toHaveStyle({
-      paddingInlineStart: 'calc(var(--spacing-10) + var(--spacing-4))',
+      paddingInlineStart: 'calc(40px + var(--spacing-4))',
     });
   });
 
-  it('sizes the chevron column at the spacing token the panel indents by', () => {
-    // The column width is a number the layout does arithmetic on, so it cannot
-    // be a token reference — but the panel's indent, which has to line up with
-    // the first column, spells it as `--spacing-10`. Pin the two together so a
-    // change to the scale cannot silently unalign them.
+  it("indents the panel by the chevron column's own width", () => {
+    // The column width is a number the layout does arithmetic on, so it stays
+    // in pixels at every root font size. The panel's indent has to line up
+    // with the first column, so it spells the same pixels, not a rem spacing
+    // token. Pin the two together so neither can move without the other.
     render(<Harness initialExpanded={new Set(['a'])} />);
     const chevronHeader = screen.getAllByRole('columnheader')[0];
-    expect(chevronHeader).toHaveStyle({width: spacingDefaults['--spacing-10']});
+    const columnWidth = getComputedStyle(chevronHeader).width;
+    const panelCell = screen
+      .getByTestId('panel')
+      .closest('td') as HTMLTableCellElement;
+    expect(columnWidth).toBe('40px');
+    expect(getComputedStyle(panelCell).paddingInlineStart).toMatch(
+      new RegExp(`^calc\\(${columnWidth} \\+ `),
+    );
+  });
+
+  it('keeps the chevron column free of the cell insets', () => {
+    // The column is fixed pixels while a cell's insets follow the spacing
+    // scale; laid out after them, the button ran past the column's edge. The
+    // body cell drops its own inline-start inset (the button then centers
+    // itself; the browser spec measures that), and the header cell drops both.
+    render(<Harness initialExpanded={new Set(['a'])} />);
+    const button = screen.getAllByRole('button', {name: /collapse row/i})[0];
+    expect(
+      getComputedStyle(button.closest('td') as HTMLTableCellElement)
+        .paddingInlineStart,
+    ).toMatch(/^0(px)?$/);
+    // The header cell holds only a hidden label; its insets alone would
+    // outgrow the 40px column at a large root font size.
+    const header = getComputedStyle(screen.getAllByRole('columnheader')[0]);
+    expect(header.paddingInlineStart).toMatch(/^0(px)?$/);
+    expect(header.paddingInlineEnd).toMatch(/^0(px)?$/);
   });
 
   describe('row divider placement', () => {

package/src/Table/plugins/rowExpansion/useTableRowExpansion.tsx

@@ -44,6 +44,7 @@ import type {
   TableColumn,
   BodyRowRenderProps,
   BodyCellRenderProps,
+  HeaderCellRenderProps,
 } from '../../types';
 
 // =============================================================================
@@ -116,12 +117,16 @@ export interface UseTableRowExpansionConfig<T extends Record<string, unknown>> {
  * The chevron column's width, in pixels.
  *
  * A column width is a number the layout does arithmetic on, not a CSS value,
- * so this cannot be a token reference — but it is the pixel value of
- * `--spacing-10`, and the panel's indent (which has to line up with the first
- * real column) spells it as the token. The unit test pins the two together so
- * a change to the scale cannot silently unalign them.
+ * so this stays a fixed pixel width at every root font size. The panel's
+ * indent, which has to line up with the first real column, spells the same
+ * pixels rather than a spacing token: spacing is rem and grows with the root
+ * font size, which would push the panel past the column it lines up with. The
+ * unit test pins the two together so neither can move without the other.
  */
 const EXPANSION_COLUMN_WIDTH_PX = 40;
+const EXPANSION_COLUMN_KEY = '__expansion';
+/** The chevron button: the spacing step, never wider than its column. */
+const CHEVRON_SIZE = `min(${spacingVars['--spacing-6']}, ${EXPANSION_COLUMN_WIDTH_PX}px)`;
 const EXPANSION_COLUMN_WIDTH = {
   type: 'pixel' as const,
   value: EXPANSION_COLUMN_WIDTH_PX,
@@ -132,8 +137,8 @@ const expansionStyles = stylex.create({
     display: 'inline-flex',
     alignItems: 'center',
     justifyContent: 'center',
-    width: spacingVars['--spacing-6'],
-    height: spacingVars['--spacing-6'],
+    width: CHEVRON_SIZE,
+    height: CHEVRON_SIZE,
     backgroundColor: 'transparent',
     borderWidth: 0,
     borderStyle: 'none',
@@ -234,17 +239,56 @@ const dividerStyles = stylex.create({
  * gives its own content.
  *
  * Written as a logical property so RTL mirrors it, and kept in `calc` so the
- * padding half still tracks the spacing scale.
+ * padding half still tracks the spacing scale, as the cell's own padding does.
  */
 const panelIndentStyles = stylex.create({
   compact: {
-    paddingInlineStart: `calc(${spacingVars['--spacing-10']} + ${spacingVars['--spacing-2']})`,
+    paddingInlineStart: `calc(${EXPANSION_COLUMN_WIDTH_PX}px + ${spacingVars['--spacing-2']})`,
   },
   balanced: {
-    paddingInlineStart: `calc(${spacingVars['--spacing-10']} + ${spacingVars['--spacing-3']})`,
+    paddingInlineStart: `calc(${EXPANSION_COLUMN_WIDTH_PX}px + ${spacingVars['--spacing-3']})`,
   },
   spacious: {
-    paddingInlineStart: `calc(${spacingVars['--spacing-10']} + ${spacingVars['--spacing-4']})`,
+    paddingInlineStart: `calc(${EXPANSION_COLUMN_WIDTH_PX}px + ${spacingVars['--spacing-4']})`,
+  },
+});
+
+/**
+ * The chevron sits centered in its column, as the selection checkbox does.
+ *
+ * The column is a fixed pixel width, but its cells' insets follow the spacing
+ * scale: the first column's edge inset, plus the density padding a body cell
+ * moves onto its right-click trigger. Laid out after both, the button ran past
+ * the column's edge, which clips its hover chip and, under a larger spacing
+ * scale or root font size, pushes the glyph out of view; and the header cell's
+ * insets alone outgrow 40px at a large root, widening the column. So the
+ * header cell, which holds only a visually hidden label, drops its inline
+ * insets, the body cell drops its inline-start inset, and the button cancels
+ * the trigger's padding (the same density step the panel indent uses) and
+ * centers itself.
+ */
+const chevronHeaderCellStyles = stylex.create({
+  cell: {
+    paddingInlineStart: 0,
+    paddingInlineEnd: 0,
+  },
+});
+
+const chevronCellStyles = stylex.create({
+  cell: {
+    paddingInlineStart: 0,
+  },
+});
+
+const chevronOffsetStyles = stylex.create({
+  compact: {
+    marginInlineStart: `calc((${EXPANSION_COLUMN_WIDTH_PX}px - ${CHEVRON_SIZE}) / 2 - ${spacingVars['--spacing-2']})`,
+  },
+  balanced: {
+    marginInlineStart: `calc((${EXPANSION_COLUMN_WIDTH_PX}px - ${CHEVRON_SIZE}) / 2 - ${spacingVars['--spacing-3']})`,
+  },
+  spacious: {
+    marginInlineStart: `calc((${EXPANSION_COLUMN_WIDTH_PX}px - ${CHEVRON_SIZE}) / 2 - ${spacingVars['--spacing-4']})`,
   },
 });
 
@@ -260,10 +304,14 @@ function ExpansionChevron({
   onToggle: () => void;
 }) {
   const t = useTranslator();
+  const ctx = useTableContext();
   return (
     <button
       type="button"
-      {...stylex.props(expansionStyles.chevronButton)}
+      {...stylex.props(
+        expansionStyles.chevronButton,
+        chevronOffsetStyles[ctx?.density ?? 'balanced'],
+      )}
       onClick={e => {
         e.stopPropagation();
         onToggle();
@@ -369,7 +417,7 @@ export function useTableRowExpansion<T extends Record<string, unknown>>(
 
   const expansionColumn = useMemo(
     (): TableColumn<T> => ({
-      key: '__expansion',
+      key: EXPANSION_COLUMN_KEY,
       // A `<th>` with no discernible text is announced as an unlabelled
       // column; the label is hidden because the column shows only chevrons.
       header: (
@@ -406,9 +454,19 @@ export function useTableRowExpansion<T extends Record<string, unknown>>(
         return withExpansion;
       },
 
+      transformHeaderCell(
+        props: HeaderCellRenderProps,
+        column: TableColumn<T>,
+      ): HeaderCellRenderProps {
+        // Keep the chevron column at its fixed width (chevronCellStyles).
+        return column.key === EXPANSION_COLUMN_KEY
+          ? {...props, xstyle: [...props.xstyle, chevronHeaderCellStyles.cell]}
+          : props;
+      },
+
       transformBodyCell(
         props: BodyCellRenderProps,
-        _column: TableColumn<T>,
+        column: TableColumn<T>,
         item: T,
       ): BodyCellRenderProps {
         // Contribute the expand/collapse action on every cell; BaseTable
@@ -423,11 +481,16 @@ export function useTableRowExpansion<T extends Record<string, unknown>>(
         const isExpanded = expandedKeys.has(key);
         return {
           ...props,
-          // Hand the row divider to the panel below, so the line closes the
-          // row-plus-panel pair instead of splitting it.
-          xstyle: isExpanded
-            ? [...props.xstyle, dividerStyles.expandedRowCell]
-            : props.xstyle,
+          xstyle: [
+            ...props.xstyle,
+            // The chevron centers itself in its column (chevronCellStyles).
+            ...(column.key === EXPANSION_COLUMN_KEY
+              ? [chevronCellStyles.cell]
+              : []),
+            // Hand the row divider to the panel below, so the line closes the
+            // row-plus-panel pair instead of splitting it.
+            ...(isExpanded ? [dividerStyles.expandedRowCell] : []),
+          ],
           contextMenuActions: () => [
             ...resolveContextActions(props.contextMenuActions),
             {

package/src/TimeInput/TouchTimeField.tsx

@@ -506,7 +506,9 @@ export function TouchTimeField({
         isOpen={isSheetOpen}
         onOpenChange={setIsSheetOpen}
         label={label}
-        height="hug">
+        height="hug"
+        // sheetBody owns the inset, including the band under the grab handle.
+        padding={0}>
         <div {...stylex.props(styles.sheetBody)}>
           <div {...stylex.props(styles.wheels)}>
             <Wheel

package/src/Tokenizer/Tokenizer.doc.mjs

@@ -180,13 +180,6 @@ export const docs = {
         'Content shown when the query matched nothing. Takes a ReactNode, so the dead end can carry a link or a create row. Announced in a polite live region as the text it renders, read from the DOM; aria-hidden parts stay out of both, and content that renders no text announces nothing. null counts as not given, like undefined, and falls through to the default; pass an empty string to render nothing.',
       default: "'No results found'",
     },
-    {
-      name: 'emptySearchResultsText',
-      type: 'string',
-      description:
-        'Deprecated: renamed to emptySearchText, which takes a ReactNode rather than a string, so every existing value stays valid. Still works exactly as released; emptySearchText wins when both are set.',
-      default: "'No results found'",
-    },
     {
       name: 'hasAutoFocus',
       type: 'boolean',
@@ -559,13 +552,6 @@ export const docsZh = {
         '查询无匹配结果时显示的内容。接受 ReactNode，因此可在无结果处放置链接或创建入口。会从 DOM 读取其渲染出的文本在礼貌性实时区域中播报；aria-hidden 的部分两处都不包含，不渲染任何文本的内容则不会播报。null 与 undefined 同样视为未提供，将回退到默认值；若要不渲染任何内容，请传入空字符串。',
       default: "'No results found'",
     },
-    {
-      name: 'emptySearchResultsText',
-      type: 'string',
-      description:
-        '已弃用：改名为 emptySearchText，其类型由 string 放宽为 ReactNode，原有取值全部仍然有效。仍按已发布行为工作；两者同时设置时以 emptySearchText 为准。',
-      default: "'No results found'",
-    },
     {
       name: 'hasAutoFocus',
       type: 'boolean',
@@ -831,8 +817,6 @@ export const docsDense = {
     minQueryLength:
       'Min query length before searching. Menu stays closed below it, except the hasCreate entry.',
     emptySearchText: 'Content when the query matched nothing. ReactNode.',
-    emptySearchResultsText:
-      'deprecated, use emptySearchText (ReactNode). still works as released; emptySearchText wins if both set.',
     hasAutoFocus: 'Auto-focus input on mount.',
     size: 'Input+token size.',
     debounceMs: 'Search debounce delay ms. 0 for sync sources.',