@vef-framework-react/components 2.3.0 → 2.4.1

package/dist/types/editable-table/components/editable-row-actions.d.ts

@@ -0,0 +1,31 @@
+import { AnyObject } from '@vef-framework-react/shared';
+import { ReactNode } from 'react';
+/**
+ * Custom labels for the built-in row action buttons.
+ */
+export interface EditableRowActionsTexts {
+    edit?: ReactNode;
+    save?: ReactNode;
+    cancel?: ReactNode;
+    delete?: ReactNode;
+}
+interface EditableRowActionsProps<TRow extends AnyObject> {
+    row: TRow;
+    index: number;
+    rowKey: string;
+    editable: boolean;
+    deletable: boolean;
+    texts?: EditableRowActionsTexts;
+    extra?: (row: TRow, index: number) => ReactNode;
+}
+/**
+ * Operation-column body. Subscribes to `editingKey` to render either the
+ * read-mode actions (caller extras + Edit/Delete) or the edit-mode actions
+ * (Save/Cancel). While any row is editing, the other rows' buttons are disabled
+ * to enforce the one-row-at-a-time contract. Save runs through ActionButton, so
+ * its async work (validation) drives the loading state automatically. Buttons
+ * are color-coded filled: primary for Edit/Save, danger for Delete, default for
+ * Cancel.
+ */
+export declare function EditableRowActions<TRow extends AnyObject>({ row, index, rowKey, editable, deletable, texts, extra }: EditableRowActionsProps<TRow>): ReactNode;
+export {};

package/dist/types/editable-table/components/index.d.ts

@@ -0,0 +1,3 @@
+export { AddRowButton } from './add-row-button';
+export { EditableCell } from './editable-cell';
+export { EditableRowActions, type EditableRowActionsTexts } from './editable-row-actions';

package/dist/types/editable-table/helpers.d.ts

@@ -0,0 +1,10 @@
+import { AnyObject, DeepKeys } from '@vef-framework-react/shared';
+import { EditableColumn, EditableColumnOptions } from './types';
+/**
+ * Type-safe factory for an {@link EditableColumn}. Splits the input into the
+ * display/slot fields and the `<form.AppField>` options (validators, listeners,
+ * …), erasing the latter into an opaque {@link ErasedFieldOptions} so a
+ * heterogeneous `EditableColumn<TRow>[]` stays a single, well-typed array.
+ * `restoreFieldOptions` (from the form module) reverses this at the render site.
+ */
+export declare function createEditableColumn<TRow extends AnyObject>(dataIndex: DeepKeys<TRow>, options?: EditableColumnOptions<TRow>): EditableColumn<TRow>;

package/dist/types/editable-table/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export { useEditableActions } from './use-editable-actions';
+export { useEditableColumns, type EditableOperationConfig } from './use-editable-columns';

package/dist/types/editable-table/hooks/use-editable-actions.d.ts

@@ -0,0 +1,29 @@
+import { AnyObject } from '@vef-framework-react/shared';
+/**
+ * Minimal view of the draft form needed to drive row editing. Kept narrow so
+ * the concrete `FormApi` (with its many validator generics) is assignable
+ * without variance friction.
+ */
+interface DraftForm<TRow> {
+    reset: (values?: TRow) => void;
+    validateAllFields: (cause: "submit") => Promise<unknown[]>;
+    state: {
+        values: TRow;
+    };
+}
+interface UseEditableActionsParams<TRow extends AnyObject> {
+    value: TRow[];
+    onChange?: (value: TRow[]) => void;
+    form: DraftForm<TRow>;
+    getKey: (row: TRow) => string;
+    rowKeyField: string | null;
+    createRecord?: () => Partial<TRow>;
+}
+/**
+ * Owns the row-editing behavior and injects it into the store. The host holds
+ * `value` / `onChange` / the draft form; cells and row actions invoke these
+ * slots through the store. Latest `value`/`onChange` are read via refs so the
+ * slots stay stable without re-injecting on every data change.
+ */
+export declare function useEditableActions<TRow extends AnyObject>({ value, onChange, form, getKey, rowKeyField, createRecord }: UseEditableActionsParams<TRow>): void;
+export {};

package/dist/types/editable-table/hooks/use-editable-columns.d.ts

@@ -0,0 +1,25 @@
+import { AnyObject } from '@vef-framework-react/shared';
+import { ReactNode } from 'react';
+import { Length } from '../../_base';
+import { TableColumn } from '../../table';
+import { EditableRowActionsTexts } from '../components';
+import { EditableColumn } from '../types';
+/**
+ * Operation-column configuration resolved by EditableTable.
+ */
+export interface EditableOperationConfig<TRow extends AnyObject> {
+    enabled: boolean;
+    title?: ReactNode;
+    width?: Length;
+    texts?: EditableRowActionsTexts;
+    editable: (row: TRow) => boolean;
+    deletable: (row: TRow) => boolean;
+    extra?: (row: TRow, index: number) => ReactNode;
+}
+/**
+ * Compile `EditableColumn<TRow>[]` into antd columns. Each data column's render
+ * returns a store-subscribed `<EditableCell>`; an operation column with the row
+ * actions is appended when enabled. Memoized on stable inputs (never on
+ * `editingKey`) so the column array reference stays stable across edit toggles.
+ */
+export declare function useEditableColumns<TRow extends AnyObject>(columns: Array<EditableColumn<TRow>>, getKey: (row: TRow) => string, operation: EditableOperationConfig<TRow>): Array<TableColumn<TRow>>;

package/dist/types/editable-table/index.d.ts

@@ -0,0 +1,14 @@
+import { AnyObject } from '@vef-framework-react/shared';
+import { ReactNode } from 'react';
+import { EditableTableProps } from './props';
+/**
+ * Controlled, inline-editable table. One row edits at a time; editing, adding
+ * and deleting rows are operations on the controlled `value` array surfaced
+ * through `onChange`. Built on the base `Table` and the form module — no
+ * query / mutation involved.
+ */
+export declare function EditableTable<TRow extends AnyObject>(props: EditableTableProps<TRow>): ReactNode;
+export type { EditableRowActionsTexts } from './components';
+export { createEditableColumn } from './helpers';
+export type { EditableOperationColumnConfig, EditableTableProps } from './props';
+export type * from './types';

package/dist/types/editable-table/props.d.ts

@@ -0,0 +1,73 @@
+import { AnyObject, DeepKeys, Key } from '@vef-framework-react/shared';
+import { ReactNode } from 'react';
+import { Length } from '../_base';
+import { TableProps } from '../table';
+import { EditableRowActionsTexts } from './components';
+import { EditableColumn } from './types';
+/**
+ * Overrides for the appended operation column.
+ */
+export interface EditableOperationColumnConfig {
+    title?: ReactNode;
+    width?: Length;
+    texts?: EditableRowActionsTexts;
+}
+/**
+ * Props for {@link EditableTable}. The component is a controlled form control:
+ * `value` is the full row array, and every edit / add / delete is just an
+ * operation on that array surfaced through `onChange` — there is no query or
+ * mutation involved.
+ */
+export interface EditableTableProps<TRow extends AnyObject> {
+    /**
+     * Controlled row data.
+     */
+    value: TRow[];
+    /**
+     * Emitted with the next array on every edit / add / delete.
+     */
+    onChange?: (value: TRow[]) => void;
+    /**
+     * Column definitions with read (`renderView`) and edit (`renderEditor`) slots.
+     */
+    columns: Array<EditableColumn<NoInfer<TRow>>>;
+    /**
+     * Row identity: a field name or a function; defaults to the `key` field.
+     * Provides stable identity for the editing row.
+     */
+    rowKey?: DeepKeys<NoInfer<TRow>> | ((row: NoInfer<TRow>) => Key);
+    /**
+     * Whether a row can enter edit mode. Accepts a boolean or a per-row
+     * predicate. Defaults to `true`.
+     */
+    canEdit?: boolean | ((row: NoInfer<TRow>) => boolean);
+    /**
+     * Whether a row can be deleted. Accepts a boolean or a per-row predicate.
+     * Defaults to `false`.
+     */
+    canDelete?: boolean | ((row: NoInfer<TRow>) => boolean);
+    /**
+     * Show the add-row button below the table.
+     */
+    creatable?: boolean;
+    /**
+     * Factory for a new row's default values when adding.
+     */
+    createRecord?: () => Partial<TRow>;
+    /**
+     * Extra read-mode actions rendered before the built-in Edit / Delete buttons.
+     */
+    renderRowActions?: (row: NoInfer<TRow>, index: number) => ReactNode;
+    /**
+     * Operation column overrides (title / width / button labels).
+     */
+    operationColumn?: EditableOperationColumnConfig;
+    /**
+     * Table density, forwarded to the underlying table.
+     */
+    size?: TableProps<NoInfer<TRow>>["size"];
+    /**
+     * Client-side pagination config, forwarded to the underlying table. Off by default.
+     */
+    pagination?: TableProps<NoInfer<TRow>>["pagination"];
+}

package/dist/types/editable-table/store.d.ts

@@ -0,0 +1,38 @@
+import { AnyObject } from '@vef-framework-react/shared';
+import { ComponentType } from 'react';
+import { StoreProviderProps, UseStore, UnboundStore } from '@vef-framework-react/core';
+/**
+ * State for the EditableTable component. Holds the single editing-row key and
+ * a set of behavior slots whose real implementations are injected by the host
+ * component (which owns `value` / `onChange` / the draft form). Leaf cells and
+ * row actions subscribe to `editingKey` to toggle their own render, so the top
+ * level never has to.
+ */
+export interface EditableTableState {
+    /**
+     * Key of the row currently being edited, or `null` when none.
+     */
+    editingKey: string | null;
+    setEditingKey: (key: string | null) => void;
+    /**
+     * Enter edit mode for a row (resets the draft form to the row's values).
+     */
+    startEdit: (rowKey: string, row: AnyObject) => void;
+    /**
+     * Validate the editing row and, on success, write it back via `onChange`.
+     */
+    save: () => Promise<void>;
+    /**
+     * Leave edit mode, discarding the draft.
+     */
+    cancel: () => void;
+    /**
+     * Append a new row and enter edit mode for it.
+     */
+    addRow: () => void;
+    /**
+     * Remove a row by key via `onChange`.
+     */
+    deleteRow: (rowKey: string) => void;
+}
+export declare const EditableTableStoreProvider: ComponentType<StoreProviderProps<never>>, useEditableTableStore: UseStore<EditableTableState>, useEditableTableStoreApi: <TStrictState extends EditableTableState = EditableTableState>() => UnboundStore<TStrictState>;

package/dist/types/editable-table/types.d.ts

@@ -0,0 +1,76 @@
+import { AnyObject, DeepKeys, Key } from '@vef-framework-react/shared';
+import { ReactNode } from 'react';
+import { fieldComponents } from '../form/fields';
+import { CreateFieldFn, ErasedFieldOptions } from '../form/helpers';
+import { TableColumn } from '../table';
+/**
+ * Render context handed to a column's editor slot, carrying the row identity
+ * so the slot can branch on the concrete record without re-deriving it.
+ */
+export interface EditFieldContext<TRow extends AnyObject> {
+    row: TRow;
+    index: number;
+    rowKey: string;
+}
+/**
+ * Read-only display slot. Renders the cell content while the row is not being
+ * edited. Falls back to the raw value when omitted.
+ */
+export type RenderView<TRow extends AnyObject> = (value: unknown, row: TRow, index: number) => ReactNode;
+/**
+ * Editor slot. Renders a form control bound to the row's draft form while the
+ * row is being edited. `field` is the injected field-component dictionary
+ * (`field.Input`, `field.Select`, …), matching `createField`'s render shape.
+ * The column is treated as read-only when omitted.
+ */
+export type RenderEditor<TRow extends AnyObject> = (field: typeof fieldComponents, context: EditFieldContext<TRow>) => ReactNode;
+/**
+ * Display-only column properties forwarded verbatim to the underlying antd column.
+ */
+type EditableColumnDisplay<TRow extends AnyObject> = Pick<TableColumn<TRow>, "title" | "width" | "minWidth" | "align" | "fixed" | "ellipsis" | "className">;
+/**
+ * Column definition for {@link EditableTable}. Replaces antd's single `render`
+ * with two slots: {@link RenderView} (read mode) and {@link RenderEditor} (edit
+ * mode). Use {@link createEditableColumn} to attach type-safe validators.
+ */
+export interface EditableColumn<TRow extends AnyObject> extends EditableColumnDisplay<TRow> {
+    /**
+     * Data key of the column; doubles as the form field name while editing.
+     */
+    dataIndex: DeepKeys<TRow>;
+    /**
+     * Stable column identity; defaults to `dataIndex`.
+     */
+    key?: Key;
+    /**
+     * Whether this column participates in editing. Defaults to `true`.
+     */
+    editable?: boolean;
+    /**
+     * Read-only display slot; falls back to the raw value when omitted.
+     */
+    renderView?: RenderView<TRow>;
+    /**
+     * Editor slot; the column stays read-only when omitted.
+     */
+    renderEditor?: RenderEditor<TRow>;
+    /**
+     * Erased `<form.AppField>` options (validators, listeners…) from `createEditableColumn`.
+     */
+    fieldOptions?: ErasedFieldOptions<TRow>;
+}
+/**
+ * Field-level options forwarded to `<form.AppField>` (validators, listeners,
+ * defaultValue…), mirroring `createField`'s input minus its render slots.
+ */
+type EditableFieldOptions<TRow extends AnyObject> = Omit<Parameters<CreateFieldFn<TRow>>[1], "render" | "renderMeta">;
+/**
+ * Input accepted by {@link createEditableColumn}: field options plus display and slot fields.
+ */
+export type EditableColumnOptions<TRow extends AnyObject> = EditableFieldOptions<TRow> & EditableColumnDisplay<TRow> & {
+    key?: Key;
+    editable?: boolean;
+    renderView?: RenderView<TRow>;
+    renderEditor?: RenderEditor<TRow>;
+};
+export {};

package/dist/types/form/fields/code-editor/index.d.ts

@@ -0,0 +1,5 @@
+import { CodeEditorFieldProps } from './props';
+import { FC } from 'react';
+import { FieldComponentProps } from '../..';
+export declare const CodeEditorField: FC<FieldComponentProps<CodeEditorFieldProps>>;
+export { type CodeEditorFieldProps } from './props';

package/dist/types/form/fields/code-editor/props.d.ts

@@ -0,0 +1,15 @@
+import { Except } from '@vef-framework-react/shared';
+import { CodeEditorProps } from '../../../code-editor';
+export interface CodeEditorFieldProps extends Except<CodeEditorProps, "value" | "defaultValue" | "onChange" | "onBlur"> {
+    /**
+     * Disable editing through the form context. Maps to `readOnly` on the
+     * underlying CodeEditor so the user can still focus and copy text.
+     */
+    disabled?: boolean;
+    /**
+     * Whether to preserve empty string instead of converting to null
+     *
+     * @default false - Empty strings will be converted to null
+     */
+    preserveEmptyString?: boolean;
+}

package/dist/types/form/fields/icon-picker/index.d.ts

@@ -0,0 +1,5 @@
+import { IconPickerFieldProps } from './props';
+import { FC } from 'react';
+import { FieldComponentProps } from '../..';
+export declare const IconPickerField: FC<FieldComponentProps<IconPickerFieldProps>>;
+export { type IconPickerFieldProps } from './props';

package/dist/types/form/fields/icon-picker/props.d.ts

@@ -0,0 +1,10 @@
+import { Except } from '@vef-framework-react/shared';
+import { IconPickerProps } from '../../../icon-picker';
+/**
+ * Props for `IconPickerField` — the {@link IconPickerProps} surface minus the
+ * value/change wiring the form owns: `value`, `defaultValue`, `onChange`, and
+ * `onBlur` all come from the field state, so they are not part of the public
+ * field props.
+ */
+export interface IconPickerFieldProps extends Except<IconPickerProps, "value" | "defaultValue" | "onChange" | "onBlur"> {
+}

package/dist/types/form/fields/index.d.ts

@@ -4,9 +4,11 @@ import { AutoCompleteFieldProps } from './auto-complete';
 import { BoolFieldProps } from './bool';
 import { CascaderFieldProps } from './cascader';
 import { CheckboxFieldProps, CheckboxGroupFieldProps } from './checkbox';
+import { CodeEditorFieldProps } from './code-editor';
 import { ColorPickerFieldProps } from './color-picker';
 import { DatePickerFieldProps } from './date-picker';
 import { DateRangePickerFieldProps } from './date-range-picker';
+import { IconPickerFieldProps } from './icon-picker';
 import { InputFieldProps } from './input';
 import { InputNumberFieldProps } from './input-number';
 import { MentionsFieldProps } from './mentions';
@@ -26,9 +28,11 @@ export type { AutoCompleteFieldProps } from './auto-complete';
 export type { BoolFieldProps } from './bool';
 export type { CascaderFieldProps } from './cascader';
 export type { CheckboxFieldProps, CheckboxGroupFieldProps } from './checkbox';
+export type { CodeEditorFieldProps } from './code-editor';
 export type { ColorPickerFieldProps } from './color-picker';
 export type { DatePickerFieldProps } from './date-picker';
 export type { DateRangePickerFieldProps } from './date-range-picker';
+export type { IconPickerFieldProps } from './icon-picker';
 export type { InputFieldProps } from './input';
 export type { InputNumberFieldProps } from './input-number';
 export type { MentionsFieldProps } from './mentions';
@@ -48,9 +52,11 @@ export declare const fieldComponents: {
     readonly Cascader: FC<FieldComponentProps<CascaderFieldProps>>;
     readonly Checkbox: FC<FieldComponentProps<CheckboxFieldProps>>;
     readonly CheckboxGroup: FC<FieldComponentProps<CheckboxGroupFieldProps>>;
+    readonly CodeEditor: FC<FieldComponentProps<CodeEditorFieldProps>>;
     readonly ColorPicker: FC<FieldComponentProps<ColorPickerFieldProps>>;
     readonly DatePicker: <TValueAsObject extends boolean = false>(props: FieldComponentProps<DatePickerFieldProps<TValueAsObject>>) => ReactNode;
     readonly DateRangePicker: <TValueAsObject extends boolean = false>(props: FieldComponentProps<DateRangePickerFieldProps<TValueAsObject>>) => ReactNode;
+    readonly IconPicker: FC<FieldComponentProps<IconPickerFieldProps>>;
     readonly Input: FC<FieldComponentProps<InputFieldProps>>;
     readonly InputNumber: FC<FieldComponentProps<InputNumberFieldProps>>;
     readonly Mentions: FC<FieldComponentProps<MentionsFieldProps>>;

package/dist/types/form/form.d.ts

@@ -2,7 +2,7 @@ import { FormAsyncValidateOrFn, FormValidateOrFn, FormOptions, AppFieldExtendedR
 import { MaybeUndefined } from '@vef-framework-react/shared';
 import { FormApi, FieldComponentProps } from './types';
 import { FC, ReactNode, FunctionComponent, PropsWithChildren } from 'react';
-import { AutoCompleteFieldProps, BoolFieldProps, CascaderFieldProps, CheckboxFieldProps, CheckboxGroupFieldProps, ColorPickerFieldProps, DatePickerFieldProps, DateRangePickerFieldProps, InputFieldProps, InputNumberFieldProps, MentionsFieldProps, RadioFieldProps, RateFieldProps, SelectFieldProps, SliderFieldProps, TextAreaFieldProps, TimePickerFieldProps, TimeRangePickerFieldProps, TransferFieldProps, TreeSelectFieldProps, UploadFieldProps } from './fields';
+import { AutoCompleteFieldProps, BoolFieldProps, CascaderFieldProps, CheckboxFieldProps, CheckboxGroupFieldProps, CodeEditorFieldProps, ColorPickerFieldProps, DatePickerFieldProps, DateRangePickerFieldProps, IconPickerFieldProps, InputFieldProps, InputNumberFieldProps, MentionsFieldProps, RadioFieldProps, RateFieldProps, SelectFieldProps, SliderFieldProps, TextAreaFieldProps, TimePickerFieldProps, TimeRangePickerFieldProps, TransferFieldProps, TreeSelectFieldProps, UploadFieldProps } from './fields';
 import { PasswordFieldProps } from './fields/password';
 import { DataOption } from '@vef-framework-react/core';
 import { Form } from './components/form';
@@ -14,9 +14,11 @@ declare const useAppForm: <TFormData, TOnMount extends FormValidateOrFn<TFormDat
     readonly Cascader: FC<FieldComponentProps<CascaderFieldProps>>;
     readonly Checkbox: FC<FieldComponentProps<CheckboxFieldProps>>;
     readonly CheckboxGroup: FC<FieldComponentProps<CheckboxGroupFieldProps>>;
+    readonly CodeEditor: FC<FieldComponentProps<CodeEditorFieldProps>>;
     readonly ColorPicker: FC<FieldComponentProps<ColorPickerFieldProps>>;
     readonly DatePicker: <TValueAsObject extends boolean = false>(props: FieldComponentProps<DatePickerFieldProps<TValueAsObject>>) => ReactNode;
     readonly DateRangePicker: <TValueAsObject extends boolean = false>(props: FieldComponentProps<DateRangePickerFieldProps<TValueAsObject>>) => ReactNode;
+    readonly IconPicker: FC<FieldComponentProps<IconPickerFieldProps>>;
     readonly Input: FC<FieldComponentProps<InputFieldProps>>;
     readonly InputNumber: FC<FieldComponentProps<InputNumberFieldProps>>;
     readonly Mentions: FC<FieldComponentProps<MentionsFieldProps>>;
@@ -41,9 +43,11 @@ declare const useAppForm: <TFormData, TOnMount extends FormValidateOrFn<TFormDat
     readonly Cascader: FC<FieldComponentProps<CascaderFieldProps>>;
     readonly Checkbox: FC<FieldComponentProps<CheckboxFieldProps>>;
     readonly CheckboxGroup: FC<FieldComponentProps<CheckboxGroupFieldProps>>;
+    readonly CodeEditor: FC<FieldComponentProps<CodeEditorFieldProps>>;
     readonly ColorPicker: FC<FieldComponentProps<ColorPickerFieldProps>>;
     readonly DatePicker: <TValueAsObject extends boolean = false>(props: FieldComponentProps<DatePickerFieldProps<TValueAsObject>>) => ReactNode;
     readonly DateRangePicker: <TValueAsObject extends boolean = false>(props: FieldComponentProps<DateRangePickerFieldProps<TValueAsObject>>) => ReactNode;
+    readonly IconPicker: FC<FieldComponentProps<IconPickerFieldProps>>;
     readonly Input: FC<FieldComponentProps<InputFieldProps>>;
     readonly InputNumber: FC<FieldComponentProps<InputNumberFieldProps>>;
     readonly Mentions: FC<FieldComponentProps<MentionsFieldProps>>;
@@ -69,9 +73,11 @@ declare const useAppForm: <TFormData, TOnMount extends FormValidateOrFn<TFormDat
         readonly Cascader: FC<FieldComponentProps<CascaderFieldProps>>;
         readonly Checkbox: FC<FieldComponentProps<CheckboxFieldProps>>;
         readonly CheckboxGroup: FC<FieldComponentProps<CheckboxGroupFieldProps>>;
+        readonly CodeEditor: FC<FieldComponentProps<CodeEditorFieldProps>>;
         readonly ColorPicker: FC<FieldComponentProps<ColorPickerFieldProps>>;
         readonly DatePicker: <TValueAsObject extends boolean = false>(props: FieldComponentProps<DatePickerFieldProps<TValueAsObject>>) => ReactNode;
         readonly DateRangePicker: <TValueAsObject extends boolean = false>(props: FieldComponentProps<DateRangePickerFieldProps<TValueAsObject>>) => ReactNode;
+        readonly IconPicker: FC<FieldComponentProps<IconPickerFieldProps>>;
         readonly Input: FC<FieldComponentProps<InputFieldProps>>;
         readonly InputNumber: FC<FieldComponentProps<InputNumberFieldProps>>;
         readonly Mentions: FC<FieldComponentProps<MentionsFieldProps>>;
@@ -97,9 +103,11 @@ declare const useAppForm: <TFormData, TOnMount extends FormValidateOrFn<TFormDat
     readonly Cascader: FC<FieldComponentProps<CascaderFieldProps>>;
     readonly Checkbox: FC<FieldComponentProps<CheckboxFieldProps>>;
     readonly CheckboxGroup: FC<FieldComponentProps<CheckboxGroupFieldProps>>;
+    readonly CodeEditor: FC<FieldComponentProps<CodeEditorFieldProps>>;
     readonly ColorPicker: FC<FieldComponentProps<ColorPickerFieldProps>>;
     readonly DatePicker: <TValueAsObject extends boolean = false>(props: FieldComponentProps<DatePickerFieldProps<TValueAsObject>>) => ReactNode;
     readonly DateRangePicker: <TValueAsObject extends boolean = false>(props: FieldComponentProps<DateRangePickerFieldProps<TValueAsObject>>) => ReactNode;
+    readonly IconPicker: FC<FieldComponentProps<IconPickerFieldProps>>;
     readonly Input: FC<FieldComponentProps<InputFieldProps>>;
     readonly InputNumber: FC<FieldComponentProps<InputNumberFieldProps>>;
     readonly Mentions: FC<FieldComponentProps<MentionsFieldProps>>;
@@ -125,9 +133,11 @@ declare const useAppForm: <TFormData, TOnMount extends FormValidateOrFn<TFormDat
         readonly Cascader: FC<FieldComponentProps<CascaderFieldProps>>;
         readonly Checkbox: FC<FieldComponentProps<CheckboxFieldProps>>;
         readonly CheckboxGroup: FC<FieldComponentProps<CheckboxGroupFieldProps>>;
+        readonly CodeEditor: FC<FieldComponentProps<CodeEditorFieldProps>>;
         readonly ColorPicker: FC<FieldComponentProps<ColorPickerFieldProps>>;
         readonly DatePicker: <TValueAsObject extends boolean = false>(props: FieldComponentProps<DatePickerFieldProps<TValueAsObject>>) => ReactNode;
         readonly DateRangePicker: <TValueAsObject extends boolean = false>(props: FieldComponentProps<DateRangePickerFieldProps<TValueAsObject>>) => ReactNode;
+        readonly IconPicker: FC<FieldComponentProps<IconPickerFieldProps>>;
         readonly Input: FC<FieldComponentProps<InputFieldProps>>;
         readonly InputNumber: FC<FieldComponentProps<InputNumberFieldProps>>;
         readonly Mentions: FC<FieldComponentProps<MentionsFieldProps>>;
@@ -152,9 +162,11 @@ declare const useAppForm: <TFormData, TOnMount extends FormValidateOrFn<TFormDat
         readonly Cascader: FC<FieldComponentProps<CascaderFieldProps>>;
         readonly Checkbox: FC<FieldComponentProps<CheckboxFieldProps>>;
         readonly CheckboxGroup: FC<FieldComponentProps<CheckboxGroupFieldProps>>;
+        readonly CodeEditor: FC<FieldComponentProps<CodeEditorFieldProps>>;
         readonly ColorPicker: FC<FieldComponentProps<ColorPickerFieldProps>>;
         readonly DatePicker: <TValueAsObject extends boolean = false>(props: FieldComponentProps<DatePickerFieldProps<TValueAsObject>>) => ReactNode;
         readonly DateRangePicker: <TValueAsObject extends boolean = false>(props: FieldComponentProps<DateRangePickerFieldProps<TValueAsObject>>) => ReactNode;
+        readonly IconPicker: FC<FieldComponentProps<IconPickerFieldProps>>;
         readonly Input: FC<FieldComponentProps<InputFieldProps>>;
         readonly InputNumber: FC<FieldComponentProps<InputNumberFieldProps>>;
         readonly Mentions: FC<FieldComponentProps<MentionsFieldProps>>;

package/dist/types/generic-select/index.d.ts

@@ -0,0 +1,15 @@
+import { PropsWithRef } from '../_base';
+import { GenericSelectProps, GenericSelectRef } from './props';
+/**
+ * The abstract base for popup-driven selection controls — the antd `Select`
+ * trigger with its dropdown body swapped for an arbitrary surface. It owns the
+ * styled trigger (selected-value display, size/status/variant/clear/disabled),
+ * the controlled open state, the in-trigger search box, and the popup container;
+ * concrete components supply only {@link GenericSelectProps.renderPopup} (the
+ * popup body) and {@link GenericSelectProps.renderLabel} (how a value renders).
+ *
+ * It is the foundation the {@link IconPicker} builds on, and is published so
+ * downstream code can build its own popup selects (e.g. a dropdown data table).
+ */
+export declare function GenericSelect<TValue extends string | number = string>({ ref, value, onChange, onBlur, open, defaultOpen, onOpenChange, renderPopup, renderLabel, searchable, placeholder, size, status, variant, disabled, allowClear, loading, suffixIcon, prefix, getPopupContainer, popupMatchSelectWidth, popupClassName, className, style }: PropsWithRef<GenericSelectRef, GenericSelectProps<TValue>>): import("@emotion/react/jsx-runtime").JSX.Element;
+export type { GenericSelectPopupApi, GenericSelectProps, GenericSelectRef, GenericSelectStatus, GenericSelectVariant } from './props';