@godxjp/ui 22.0.0 → 23.0.0

package/dist/props/components/data-entry.prop.d.ts

@@ -1,5 +1,4 @@
 /** Data Entry component prop types — @see docs/COMPONENTS.md#data-entry */
-import type * as SliderPrimitive from "@radix-ui/react-slider";
 import type { RenderProps as InputOTPRenderProps } from "input-otp";
 import type { DayPickerProps } from "react-day-picker";
 import type { DateRange } from "react-day-picker";
@@ -36,8 +35,15 @@ export type InputOTPMaskProp = boolean | string;
  * The value is ALWAYS driven from here (`value` controlled, or `defaultValue` + internal state), so
  * `formatter` and `readOnly` hold for typing AND for paste — `input-otp` writes its own internal
  * state on paste, which a wrapper that only intercepted `onChange` could not undo.
+ *
+ * `style` is OMITTED because it cannot be honoured: `input-otp` owns both elements it could land
+ * on and writes their geometry itself — the field's own style object replaces anything passed in
+ * (measured: `style={{ color: "red" }}` left the input at the library's `color: transparent`) and
+ * the container's is hard-coded too. A type that accepts a prop the render can never deliver is
+ * the defect gh#477 reported for `id`; `id` is real and forwarded, this one was not. The paint of
+ * the field is reached through `className` / `containerClassName` and the `--otp-*` tokens.
  */
-export type InputOTPProp = Omit<React.InputHTMLAttributes<HTMLInputElement>, "value" | "defaultValue" | "onChange" | "size" | "children"> & {
+export type InputOTPProp = Omit<React.InputHTMLAttributes<HTMLInputElement>, "value" | "defaultValue" | "onChange" | "size" | "children" | "style"> & {
     /** Number of slots — antd `length`. Required by `input-otp`. */
     maxLength: number;
     value?: string;
@@ -528,43 +534,157 @@ export type FieldProp = {
     children: React.ReactNode;
 };
 /**
- * Tick marks on a slider rail — antd `SliderMarks`. Keyed by the value the mark sits on; the
- * value is the label. `null` renders the tick with no label.
+ * One tick on a slider rail — antd's two spellings: the label itself, or `{ label, style }` where
+ * the object also carries a per-mark inline style. `null` renders the tick with no label.
+ */
+export type SliderMarkProp = React.ReactNode | {
+    label?: React.ReactNode;
+    /** antd's per-mark style. Prefer styling the `label` node — it is already a ReactNode. */
+    style?: React.CSSProperties;
+};
+/**
+ * Tick marks on a slider rail — antd `SliderMarks`. Keyed by the value the mark sits on. With
+ * `step={null}` the marks (plus `min` and `max`) are the ONLY values the slider can take.
  */
-export type SliderMarksProp = Record<number, React.ReactNode>;
+export type SliderMarksProp = Record<number, SliderMarkProp>;
 /**
- * antd `tooltip` — the value bubble over a dragging thumb. `false` switches it off, `true` uses
- * the raw value, and the object form formats it (a unit, a currency, a 全角 label).
+ * antd `tooltip` — the value bubble over a thumb. `false` switches it off, `true` uses the raw
+ * value, and the object form formats and places it.
  */
 export type SliderTooltipProp = boolean | {
-    /** Force the bubble on/off instead of following hover/drag. */
+    /**
+     * `true` keeps the bubble visible; `false` keeps it hidden even while dragging or hovering —
+     * both exactly as antd. Unset, it follows hover, keyboard focus and drag.
+     */
     open?: boolean;
-    /** Render the bubble's content. `null` switches the bubble off, exactly as antd's does. */
+    /**
+     * Which side of the thumb. `left` / `right` are the INLINE sides and mirror under RTL like
+     * the rest of the slider. Defaults to `top`, or `right` on a vertical slider (antd's default).
+     */
+    placement?: "top" | "bottom" | "left" | "right";
+    /** Flip to the opposite side when the bubble would leave the viewport. Default `true`. */
+    autoAdjustOverflow?: boolean;
+    /**
+     * Render the bubble's content. `null` switches the bubble off, exactly as antd's does. A
+     * string or number result is ALSO the thumb's `aria-valuetext`, so a `¥50,000` slider is
+     * announced as ¥50,000 and not as a bare 50000.
+     */
     formatter?: ((value: number) => React.ReactNode) | null;
 };
-/** @see Slider — numeric range (Radix Slider). */
-export type SliderProp = React.ComponentPropsWithoutRef<typeof SliderPrimitive.Root> & {
+/**
+ * antd's range object — `range={{ editable, minCount, maxCount, draggableTrack }}`. Any object is
+ * a range, exactly like `range={true}`.
+ */
+export type SliderRangeConfigProp = {
+    /**
+     * Thumbs can be added and removed: a press on the rail ADDS one there, and Delete / Backspace on
+     * a focused thumb removes it. Ignored while any thumb is disabled, and wins over `draggableTrack`
+     * — both exactly as antd.
+     */
+    editable?: boolean;
+    /** Fewest thumbs `editable` may leave. Default 0. */
+    minCount?: number;
+    /** Most thumbs `editable` may create. Default unlimited. */
+    maxCount?: number;
+    /** Drag the painted span to move every thumb at once, keeping their distance. */
+    draggableTrack?: boolean;
+};
+/**
+ * @see Slider — numeric slider on react-aria-components, antd 6 `Slider` API.
+ *
+ * Written out rather than derived from the primitive, so what is public is exactly what is listed
+ * here: the Radix-era spelling (`number[]` values, `onValueChange`, `onValueCommit`, `inverted`,
+ * `dir`, `minStepsBetweenThumbs`) keeps compiling beside antd's (`number` values, `onChange`,
+ * `onChangeComplete`, `reverse`, `vertical`, `range` objects, `step={null}`).
+ *
+ * The union is on `range`, as in antd: without it `onChange` reports a `number`, with a literal
+ * `range` (or a range object) it reports `number[]`. A `range` held in a boolean variable cannot
+ * say which, so that spelling takes `onValueChange` — which always reports every thumb.
+ */
+export type SliderProp = Omit<React.HTMLAttributes<HTMLDivElement>, "defaultValue" | "onChange" | "dir" | "children"> & {
+    /** The low end of the scale. Default 0. */
+    min?: number;
+    /** The high end of the scale. Default 100. */
+    max?: number;
+    /**
+     * Granularity. `null` is antd's marks-only mode: the thumbs can only rest on a mark, `min` or
+     * `max`. Default 1.
+     */
+    step?: number | null;
     /**
-     * antd `range` — two thumbs bounding a span rather than one thumb over a point. It is a
-     * DECLARATION, not an inference: a single-thumb slider whose `defaultValue` happens to be a
-     * two-element array used to become a range by accident, and a range whose value arrived
-     * asynchronously used to render as a point.
+     * Disable the whole slider, or — antd's array form — one thumb each: `[true, false]` locks the
+     * first thumb of a range. A disabled thumb leaves the tab order and does not submit.
      */
-    range?: boolean;
+    disabled?: boolean | boolean[];
+    /** Layout axis. Default `horizontal`. Wins over `vertical`, as in antd 6. */
+    orientation?: "horizontal" | "vertical";
+    /** antd's boolean spelling of `orientation="vertical"`. */
+    vertical?: boolean;
+    /**
+     * Reading direction of a horizontal slider — which end is `min` and which arrow increases.
+     * Defaults to the locale's direction (the `I18nProvider` that `AppProvider` sets).
+     */
+    dir?: "ltr" | "rtl";
+    /** antd `reverse` — run the scale the other way (`min` at the inline end, or at the top). */
+    reverse?: boolean;
+    /** The Radix-era name for `reverse`. When both are given, `inverted` wins. */
+    inverted?: boolean;
+    /** Radix-era: the fewest steps two neighbouring thumbs may be apart. Default 0. */
+    minStepsBetweenThumbs?: number;
+    /** Every change, with EVERY thumb — the Radix-era callback, valid in every spelling. */
+    onValueChange?: (value: number[]) => void;
+    /** Once per finished gesture (pointer release, key press), with every thumb. */
+    onValueCommit?: (value: number[]) => void;
+    /**
+     * Native form field name. One thumb submits `name`; several submit `name[]`, once each.
+     */
+    name?: string;
+    /** Associate the thumbs' inputs with a form elsewhere in the document, by id. */
+    form?: string;
     /** antd `marks` — labelled ticks along the rail. */
     marks?: SliderMarksProp;
-    /** antd `dots` — a tick at every `step`. Requires a `step`. */
+    /** antd `dots` — a tick at every `step` (at every mark when `step={null}`). */
     dots?: boolean;
     /**
-     * antd `included` — whether the painted range is the span from the start to the thumb
-     * (`true`, the default) or nothing at all (`false`, for a rail that only holds marks).
+     * antd `included` — whether the painted span runs from the start to the thumb (`true`, the
+     * default) or nothing is painted at all (`false`, for a rail that only holds marks).
      */
     included?: boolean;
-    /** antd `reverse` — run the scale the other way. Radix spells the same thing `inverted`. */
-    reverse?: boolean;
-    /** antd `tooltip` — the value bubble over a dragging thumb. Off by default. */
+    /** antd `tooltip` — the value bubble over a thumb. Off by default. */
     tooltip?: SliderTooltipProp;
-};
+} & ({
+    /**
+     * One thumb. An array `value` with no `range` still draws a thumb per entry — the
+     * Radix-era inference — but `onChange` then reports only the first; use `onValueChange`
+     * for all of them, or declare `range`.
+     */
+    range?: false;
+    /** Controlled value — a number, or the Radix-era `number[]`. */
+    value?: number | number[];
+    /** Uncontrolled initial value. With nothing given the thumb starts at `min`. */
+    defaultValue?: number | number[];
+    /** antd `onChange` — every change, as a number. */
+    onChange?: (value: number) => void;
+    /** antd `onChangeComplete` — pointer release / key press, as a number. */
+    onChangeComplete?: (value: number) => void;
+} | {
+    /**
+     * antd `range` — two or more thumbs bounding spans. A DECLARATION: a range whose value is
+     * still loading does not render as a point, and without a value it spans `[min, max]`.
+     */
+    range: true | SliderRangeConfigProp;
+    value?: number[];
+    defaultValue?: number[];
+    onChange?: (value: number[]) => void;
+    onChangeComplete?: (value: number[]) => void;
+} | {
+    /** A `range` known only at run time (a boolean variable) — report through `onValueChange`. */
+    range: boolean;
+    value?: number | number[];
+    defaultValue?: number | number[];
+    onChange?: never;
+    onChangeComplete?: never;
+});
 /** @see Calendar — react-day-picker DayPicker plus an opt-in footer. */
 /**
  * Decorate one day cell — antd's `cellRender`, in the shape the Japanese market actually needs it:
@@ -910,13 +1030,77 @@ export type SearchSelectLoadResultProp = {
     /** True if another page is available (drives infinite scroll). */
     hasMore?: boolean;
 };
+/**
+ * antd `fieldNames` — read rows in a FOREIGN shape (`{id, name}`, `{code, title}`) without mapping
+ * them first. The spelling matches the `fieldNames` Cascader and TreeSelect already take.
+ */
+export type SelectFieldNamesProp = {
+    label?: string;
+    value?: string;
+    /** Key holding a group's child rows — antd nests a group's options under the group. */
+    options?: string;
+    /** Key holding a group's heading; defaults to `label`, as in antd. */
+    groupLabel?: string;
+    disabled?: string;
+};
+/**
+ * A GROUP in antd's nested `options` shape — a heading plus its own rows. The flat
+ * `option.group` spelling this library already had keeps working; both arrive at the same list.
+ */
+export type SelectOptionGroupProp = {
+    label: string;
+    options: SearchSelectOptionProp[];
+    disabled?: boolean;
+};
+/** What `<Select options>` accepts: a row, a group of rows, or (with `fieldNames`) a foreign row. */
+export type SelectOptionInputProp = SearchSelectOptionProp | SelectOptionGroupProp | Record<string, unknown>;
+/**
+ * antd `labelInValue` — the value carries its own label, so a screen that only ever sees
+ * `{ value, label }` never has to keep the option list around to render what was picked (an async
+ * edit form whose page has not loaded yet is the case that needs it).
+ */
+export type SelectLabeledValueProp = {
+    value: string;
+    label: React.ReactNode;
+};
+/**
+ * antd `placement`, spelled on the LOGICAL inline axis — the same vocabulary
+ * `DropdownMenuPlacementProp` publishes, and for the same reason: antd's `bottomLeft` / `topRight`
+ * cannot mirror for an Arabic or Hebrew layout.
+ */
+export type SelectPlacementProp = "bottomStart" | "bottomEnd" | "topStart" | "topEnd";
+/**
+ * antd `showSearch`'s OBJECT form. Every field is the antd one, including
+ * `filterOption(input, option)` — note the argument order is antd's here, while the long-standing
+ * top-level `filterOption(option, query)` keeps this library's. Pass whichever you prefer; the
+ * object form wins when both are given.
+ */
+export type SelectShowSearchProp = {
+    /** `false` keeps every row (a server-filtered list); a function decides per row. */
+    filterOption?: boolean | ((input: string, option: SearchSelectOptionProp) => boolean);
+    /** Which field the default filter matches. antd's default is `value`; `label` is the common one. */
+    optionFilterProp?: "label" | "value" | "sublabel";
+    filterSort?: (a: SearchSelectOptionProp, b: SearchSelectOptionProp, info: {
+        searchValue: string;
+    }) => number;
+    searchValue?: string;
+    onSearch?: (value: string) => void;
+    autoClearSearchValue?: boolean;
+};
 /**
  * @see Select — the data-driven entry point (`<Select options|loadOptions showSearch …/>`).
  * This is the shape of its internal engine (`SelectDataProp` extends it); use `Select` directly.
  */
 export type SearchSelectBaseProp = {
-    /** Static option list (client-side filtered). Provide this OR `loadOptions`, not both. */
-    options?: SearchSelectOptionProp[];
+    /**
+     * Static option list (client-side filtered). Provide this OR `loadOptions`, not both.
+     *
+     * A row, or one of antd's nested GROUPS (`{ label, options }`) — both land in the same list, the
+     * group's heading becoming the `group` this library's flat rows already carry. Rows in a foreign
+     * shape go through `fieldNames` and need a cast at the call site, exactly as Cascader's and
+     * TreeSelect's do.
+     */
+    options?: (SearchSelectOptionProp | SelectOptionGroupProp)[];
     /** Remote fetcher — debounced search + infinite-scroll pagination call into this. Provide this
      *  OR `options`. */
     loadOptions?: (params: SearchSelectLoadParamsProp) => Promise<SearchSelectLoadResultProp>;
@@ -1068,6 +1252,45 @@ export type SearchSelectBaseProp = {
     "data-testid"?: string;
     /** Normally injected by `FormField`. */
     "data-field"?: string;
+    /**
+     * antd `fieldNames` — map `{label, value, options, groupLabel, disabled}` onto foreign rows, so a
+     * server payload can be passed straight through instead of being copied into a second array.
+     */
+    fieldNames?: SelectFieldNamesProp;
+    /**
+     * antd `prefix` — a node pinned BEFORE the value on the trigger (a currency mark, an icon, a
+     * "To:" label). Decorative: it is not part of the control's accessible name.
+     */
+    prefix?: React.ReactNode;
+    /**
+     * antd `suffixIcon` — replaces the trailing chevron. `null` removes the indicator entirely (antd
+     * spells that `showArrow={false}`, which it deprecated in favour of exactly this).
+     */
+    suffixIcon?: React.ReactNode;
+    /**
+     * antd `placement`, on the logical inline axis. Absent = `bottomStart` with collision flipping,
+     * which is what a picker wants; set it only when the popup must open a specific way.
+     */
+    placement?: SelectPlacementProp;
+    /**
+     * antd `popupRender` — wrap the popup's own node (add a footer, a "create" action, a hint line).
+     * Receives the list and must render it: dropping `originNode` leaves a popup with no options.
+     */
+    popupRender?: (originNode: React.ReactNode) => React.ReactNode;
+    /**
+     * antd `listHeight` — the option list's maximum height in px. It overrides
+     * `--select-content-max-height` for this one control; the token stays the default everywhere
+     * else, so this is a per-instance override of a knob, not a new hard-coded height.
+     */
+    listHeight?: number;
+    /** antd `onPopupScroll` — fires on the option list's own scroll (an infinite-scroll hook). */
+    onPopupScroll?: (event: React.UIEvent<HTMLElement>) => void;
+    /**
+     * antd `optionFilterProp` — which field the default filter matches while searching. antd's
+     * default is `value`; this library keeps matching BOTH label and value when it is unset, because
+     * every call site that has ever relied on the default expects a label search.
+     */
+    optionFilterProp?: "label" | "value" | "sublabel";
 };
 /**
  * Single-select (the default): one `string` in, one `string` out — `""` means nothing selected.
@@ -1075,6 +1298,8 @@ export type SearchSelectBaseProp = {
  */
 export type SearchSelectSingleProp = {
     mode?: undefined;
+    /** @see SelectLabelInValueSingleProp for the `{value,label}` dialect. */
+    labelInValue?: false;
     value?: ValueProp;
     /** Uncontrolled initial value — the trigger shows its option's label at rest (controlled-triad). */
     defaultValue?: DefaultValueProp;
@@ -1092,7 +1317,13 @@ export type SearchSelectSingleProp = {
  * per-chip remove button inside it would be a button nested in a button.
  */
 export type SearchSelectMultipleProp = {
-    mode: "multiple";
+    /**
+     * `multiple` picks from the list; `tags` also ACCEPTS what was typed, so a value that is not in
+     * the list can still be committed (antd's own distinction between the two).
+     */
+    mode: "multiple" | "tags";
+    /** @see SelectLabelInValueMultipleProp for the `{value,label}` dialect. */
+    labelInValue?: false;
     value?: ValueProp<string[]>;
     /** Uncontrolled initial selection (controlled-triad). */
     defaultValue?: DefaultValueProp<string[]>;
@@ -1111,6 +1342,64 @@ export type SearchSelectMultipleProp = {
     maxTagCount?: MaxTagCountProp;
     /** The node standing in for what `maxTagCount` hid (antd `maxTagPlaceholder`). */
     maxTagPlaceholder?: MaxTagPlaceholderProp;
+    /**
+     * antd `maxTagTextLength` — cut each chip's text to this many characters (an ellipsis marks the
+     * cut). It trims what the TRIGGER shows only; the value keeps its whole label.
+     */
+    maxTagTextLength?: number;
+    /**
+     * antd `tagRender` — render one chip yourself. Exactly the shape `TagInput`'s `tagRender` takes,
+     * so the two chip surfaces in this library are configured the same way. The `onClose` handed in
+     * is the same remover the built-in ✕ calls, so a custom chip cannot end up unremovable.
+     */
+    tagRender?: (props: {
+        value: string;
+        label: React.ReactNode;
+        onClose: () => void;
+        index: number;
+        disabled: boolean;
+    }) => React.ReactNode;
+    /**
+     * antd `tokenSeparators` — characters that commit what has been typed. Typing or PASTING
+     * "a,b,c" with `[","]` commits three values in one change, which is the point: a run pasted out
+     * of a spreadsheet becomes a selection instead of one long nonsense token. In `mode="multiple"`
+     * a token only counts when it matches a row; in `mode="tags"` it is accepted as it stands.
+     */
+    tokenSeparators?: string[];
+};
+/**
+ * antd `labelInValue`, single. The value carries its own label, so a screen that never sees the
+ * option list can still render what was picked.
+ */
+export type SelectLabelInValueSingleProp = {
+    labelInValue: true;
+    mode?: undefined;
+    value?: SelectLabeledValueProp | null;
+    defaultValue?: SelectLabeledValueProp | null;
+    onValueChange?: (value: SelectLabeledValueProp | undefined, option?: SearchSelectOptionProp) => void;
+    onSelect?: (value: SelectLabeledValueProp, option: SearchSelectOptionProp) => void;
+};
+/** antd `labelInValue`, multiple/tags. */
+export type SelectLabelInValueMultipleProp = {
+    labelInValue: true;
+    mode: "multiple" | "tags";
+    value?: SelectLabeledValueProp[];
+    defaultValue?: SelectLabeledValueProp[];
+    onValueChange?: (value: SelectLabeledValueProp[], options?: SearchSelectOptionProp[]) => void;
+    onSelect?: (value: SelectLabeledValueProp, option: SearchSelectOptionProp) => void;
+    onDeselect?: (value: SelectLabeledValueProp, option: SearchSelectOptionProp) => void;
+    maxCount?: number;
+    maxTagCount?: MaxTagCountProp;
+    maxTagPlaceholder?: MaxTagPlaceholderProp;
+    maxTagTextLength?: number;
+    tokenSeparators?: string[];
+    tagRender?: (props: {
+        value: string;
+        label: React.ReactNode;
+        onClose: () => void;
+        index: number;
+        disabled: boolean;
+    }) => React.ReactNode;
 };
 /** @see Select — the searchable engine. Single by default; `mode="multiple"` switches the shape. */
 export type SearchSelectProp = SearchSelectBaseProp & (SearchSelectSingleProp | SearchSelectMultipleProp);
@@ -1121,11 +1410,15 @@ export type SearchSelectProp = SearchSelectBaseProp & (SearchSelectSingleProp |
  */
 export type SelectDataProp = SearchSelectBaseProp & {
     /**
-     * Show the search box (combobox). Defaults to true when `loadOptions` is set or
-     * `mode="multiple"` is in force (antd's own defaults), otherwise false.
+     * Show the search box (combobox). Defaults to true when `loadOptions` is set or a multi-value
+     * `mode` is in force (antd's own defaults), otherwise false.
+     *
+     * The OBJECT form is antd's, and configures the search in one place —
+     * `{ filterOption, optionFilterProp, filterSort, searchValue, onSearch, autoClearSearchValue }`.
+     * Passing it also turns the search on.
      */
-    showSearch?: boolean;
-} & (SearchSelectSingleProp | SearchSelectMultipleProp);
+    showSearch?: boolean | SelectShowSearchProp;
+} & (SearchSelectSingleProp | SearchSelectMultipleProp | SelectLabelInValueSingleProp | SelectLabelInValueMultipleProp);
 /** @see UploadFileItem */
 export type UploadFileItemProp = UploadFileItem;
 /** @see Upload */

package/dist/props/components/index.d.ts

@@ -5,6 +5,6 @@ export type { AvatarProp, EmptyStateProp, DescriptionsProp, DescriptionsItemProp
 export type { ChartDatum, ChartSeriesProp, LineChartProp, BarChartProp, AreaChartProp, PieChartProp, } from "./charts.prop.js";
 export type { AlertQueryErrorProp, AlertProp, AlertTitleProp, AlertContentProp, AlertDescriptionProp, AlertActionsProp, SheetResponsiveProp, SkeletonRowsProp, } from "./feedback.prop.js";
 export type { DataStateProp, InfiniteQueryStateProp, InfiniteQueryHelpers, PrefetchLinkProp, } from "./query.prop.js";
-export type { DropdownMenuPlacementProp, PaginationProp, PaginationSizeProp, PaginationAlignProp, StepsProp, StepItemProp, StepStatusProp, StepsTypeProp, TabsProp, TabItemProp, TabsVariantProp, TabsPlacementProp, TabsExtraProp, TabsOnEditProp, } from "./navigation.prop.js";
+export type { DropdownMenuPlacementProp, DropdownMenuTriggerActionProp, PaginationProp, PaginationSizeProp, PaginationAlignProp, StepsProp, StepItemProp, StepStatusProp, StepsTypeProp, TabsProp, TabItemProp, TabsVariantProp, TabsPlacementProp, TabsExtraProp, TabsOnEditProp, } from "./navigation.prop.js";
 export type { AppProviderProp, AppContextValue, AppSettingKind, AppSettingPickerProp, AppSettingToggleKind, AppSettingToggleProp, } from "./app.prop.js";
 export type { ZodSchemaProp, UseZodFormOptionsProp, UseZodFormReturnProp, FormRootProp, FormFieldControlProp, FieldErrorMessageProp, } from "./form.prop.js";

package/dist/props/components/navigation.prop.d.ts

@@ -172,6 +172,23 @@ export type PaginationAlignProp = "start" | "center" | "end";
  * inline-side ones (antd `left*` / `right*`) stay on Radix's own physical `side`.
  */
 export type DropdownMenuPlacementProp = "top" | "topStart" | "topEnd" | "bottom" | "bottomStart" | "bottomEnd";
+/**
+ * @see DropdownMenu — Ant Design `trigger`: the gestures that open the menu, as an array because
+ * more than one may be live at once (`['click', 'contextMenu']` is a row that opens from its kebab
+ * AND from a right click anywhere on it).
+ *
+ * Default `['click']`, NOT antd's `['hover']`: a menu button that opens on hover is a pointer-only
+ * affordance by default, and every consumer of this library today opens on click.
+ *
+ * `contextMenu` opens at the pointer and suppresses the browser's own menu. It is what replaced the
+ * deleted `ContextMenu` component (v23) — antd has no such component either, and expresses the
+ * whole idea as this value.
+ *
+ * Whatever the array says, the KEYBOARD opener stays wired: Enter / Space / ArrowDown on the
+ * trigger for `click` and `hover`, and Shift+F10 / the ContextMenu key for `contextMenu`. A gesture
+ * list can therefore never produce a menu that only a mouse can reach (WCAG 2.1.1).
+ */
+export type DropdownMenuTriggerActionProp = "click" | "hover" | "contextMenu";
 export type StepStatusProp = "wait" | "process" | "finish" | "error";
 /** @see StepItem */
 export type StepItemProp = {

package/dist/props/registry.d.ts

@@ -1259,6 +1259,16 @@ export declare const COMPONENT_PROP_REGISTRY: {
         readonly file: "components/data-entry.prop.ts";
         readonly vocabulary: readonly [];
     };
+    readonly SliderMarkProp: {
+        readonly group: "data-entry";
+        readonly file: "components/data-entry.prop.ts";
+        readonly vocabulary: readonly [];
+    };
+    readonly SliderRangeConfigProp: {
+        readonly group: "data-entry";
+        readonly file: "components/data-entry.prop.ts";
+        readonly vocabulary: readonly [];
+    };
     readonly ControlCountProp: {
         readonly group: "data-entry";
         readonly file: "components/data-entry.prop.ts";
@@ -1353,6 +1363,54 @@ export declare const COMPONENT_PROP_REGISTRY: {
         readonly vocabulary: readonly ["ValueProp", "OnValueChangeProp", "PlaceholderProp", "EmptyMessageProp", "DisabledProp", "NameProp", "IdProp", "ClassNameProp", "OpenProp", "OnOpenChangeProp", "SizeProp", "DefaultOpenProp", "ControlStatusProp", "ControlVariantProp", "AllowClearProp", "NotFoundContentProp", "PopupMatchWidthProp", "PendingProp"];
         readonly note: "Internal — the searchable engine behind `<Select options showSearch>` (not public API); use Select.";
     };
+    readonly SelectFieldNamesProp: {
+        readonly group: "data-entry";
+        readonly file: "components/data-entry.prop.ts";
+        readonly vocabulary: readonly ["LabelProp", "ValueProp", "DisabledProp"];
+        readonly note: "antd `fieldNames` for `<Select options>` — the spelling Cascader and TreeSelect already take.";
+    };
+    readonly SelectOptionGroupProp: {
+        readonly group: "data-entry";
+        readonly file: "components/data-entry.prop.ts";
+        readonly vocabulary: readonly ["LabelProp", "DisabledProp"];
+        readonly note: "antd's nested option GROUP (`{ label, options }`); flattens to the `group` a flat row carries.";
+    };
+    readonly SelectOptionInputProp: {
+        readonly group: "data-entry";
+        readonly file: "components/data-entry.prop.ts";
+        readonly vocabulary: readonly [];
+        readonly note: "What `<Select options>` accepts: a row, a group, or a foreign row read through `fieldNames`.";
+    };
+    readonly SelectLabeledValueProp: {
+        readonly group: "data-entry";
+        readonly file: "components/data-entry.prop.ts";
+        readonly vocabulary: readonly ["ValueProp", "LabelProp"];
+        readonly note: "antd `labelInValue` — the value carries its own label for a screen with no option list yet.";
+    };
+    readonly SelectPlacementProp: {
+        readonly group: "data-entry";
+        readonly file: "components/data-entry.prop.ts";
+        readonly vocabulary: readonly [];
+        readonly note: "antd `placement` on the LOGICAL inline axis, as DropdownMenuPlacementProp already spells it.";
+    };
+    readonly SelectShowSearchProp: {
+        readonly group: "data-entry";
+        readonly file: "components/data-entry.prop.ts";
+        readonly vocabulary: readonly ["OnSearchChangeProp"];
+        readonly note: "antd `showSearch`'s object form. `filterOption(input, option)` here takes antd's argument order.";
+    };
+    readonly SelectLabelInValueSingleProp: {
+        readonly group: "data-entry";
+        readonly file: "components/data-entry.prop.ts";
+        readonly vocabulary: readonly ["ValueProp", "DefaultValueProp", "OnValueChangeProp"];
+        readonly note: "Internal — the `labelInValue` single shape of `<Select options>`; use Select.";
+    };
+    readonly SelectLabelInValueMultipleProp: {
+        readonly group: "data-entry";
+        readonly file: "components/data-entry.prop.ts";
+        readonly vocabulary: readonly ["ValueProp", "DefaultValueProp", "OnValueChangeProp", "MaxTagCountProp", "MaxTagPlaceholderProp"];
+        readonly note: "Internal — the `labelInValue` multiple/tags shape of `<Select options>`; use Select.";
+    };
     readonly SelectDataProp: {
         readonly group: "data-entry";
         readonly file: "components/data-entry.prop.ts";
@@ -1922,6 +1980,11 @@ export declare const COMPONENT_PROP_REGISTRY: {
         readonly file: "components/navigation.prop.ts";
         readonly vocabulary: readonly [];
     };
+    readonly DropdownMenuTriggerActionProp: {
+        readonly group: "navigation";
+        readonly file: "components/navigation.prop.ts";
+        readonly vocabulary: readonly [];
+    };
     readonly PaginationAlignProp: {
         readonly group: "navigation";
         readonly file: "components/navigation.prop.ts";

package/dist/props/registry.js

@@ -1420,6 +1420,16 @@ const COMPONENT_PROP_REGISTRY = {
     file: "components/data-entry.prop.ts",
     vocabulary: []
   },
+  SliderMarkProp: {
+    group: "data-entry",
+    file: "components/data-entry.prop.ts",
+    vocabulary: []
+  },
+  SliderRangeConfigProp: {
+    group: "data-entry",
+    file: "components/data-entry.prop.ts",
+    vocabulary: []
+  },
   ControlCountProp: {
     group: "data-entry",
     file: "components/data-entry.prop.ts",
@@ -1564,6 +1574,60 @@ const COMPONENT_PROP_REGISTRY = {
     ],
     note: "Internal \u2014 the searchable engine behind `<Select options showSearch>` (not public API); use Select."
   },
+  SelectFieldNamesProp: {
+    group: "data-entry",
+    file: "components/data-entry.prop.ts",
+    vocabulary: ["LabelProp", "ValueProp", "DisabledProp"],
+    note: "antd `fieldNames` for `<Select options>` \u2014 the spelling Cascader and TreeSelect already take."
+  },
+  SelectOptionGroupProp: {
+    group: "data-entry",
+    file: "components/data-entry.prop.ts",
+    vocabulary: ["LabelProp", "DisabledProp"],
+    note: "antd's nested option GROUP (`{ label, options }`); flattens to the `group` a flat row carries."
+  },
+  SelectOptionInputProp: {
+    group: "data-entry",
+    file: "components/data-entry.prop.ts",
+    vocabulary: [],
+    note: "What `<Select options>` accepts: a row, a group, or a foreign row read through `fieldNames`."
+  },
+  SelectLabeledValueProp: {
+    group: "data-entry",
+    file: "components/data-entry.prop.ts",
+    vocabulary: ["ValueProp", "LabelProp"],
+    note: "antd `labelInValue` \u2014 the value carries its own label for a screen with no option list yet."
+  },
+  SelectPlacementProp: {
+    group: "data-entry",
+    file: "components/data-entry.prop.ts",
+    vocabulary: [],
+    note: "antd `placement` on the LOGICAL inline axis, as DropdownMenuPlacementProp already spells it."
+  },
+  SelectShowSearchProp: {
+    group: "data-entry",
+    file: "components/data-entry.prop.ts",
+    vocabulary: ["OnSearchChangeProp"],
+    note: "antd `showSearch`'s object form. `filterOption(input, option)` here takes antd's argument order."
+  },
+  SelectLabelInValueSingleProp: {
+    group: "data-entry",
+    file: "components/data-entry.prop.ts",
+    vocabulary: ["ValueProp", "DefaultValueProp", "OnValueChangeProp"],
+    note: "Internal \u2014 the `labelInValue` single shape of `<Select options>`; use Select."
+  },
+  SelectLabelInValueMultipleProp: {
+    group: "data-entry",
+    file: "components/data-entry.prop.ts",
+    vocabulary: [
+      "ValueProp",
+      "DefaultValueProp",
+      "OnValueChangeProp",
+      "MaxTagCountProp",
+      "MaxTagPlaceholderProp"
+    ],
+    note: "Internal \u2014 the `labelInValue` multiple/tags shape of `<Select options>`; use Select."
+  },
   SelectDataProp: {
     group: "data-entry",
     file: "components/data-entry.prop.ts",
@@ -2224,6 +2288,11 @@ const COMPONENT_PROP_REGISTRY = {
     file: "components/navigation.prop.ts",
     vocabulary: []
   },
+  DropdownMenuTriggerActionProp: {
+    group: "navigation",
+    file: "components/navigation.prop.ts",
+    vocabulary: []
+  },
   PaginationAlignProp: {
     group: "navigation",
     file: "components/navigation.prop.ts",