@central-design-system/components 3.0.0-alpha.0 → 3.0.0-alpha.10

package/dist/components/CdsTable/composable/table.d.ts

@@ -0,0 +1,640 @@
+import { CdsTooltip } from '../../CdsTooltip';
+import type { PropType, Ref } from 'vue';
+import type { ComponentProps } from '../../../utils';
+import type { NTable } from '../interface';
+export interface ITableProps<RecordType = NTable.TDefaultRecord> {
+    id?: string;
+    data?: RecordType[];
+    columns?: NTable.NColumn.TColumns<RecordType>;
+    rowKey?: string | NTable.NRow.TGetRowKey<RecordType>;
+    rowClassName?: string | NTable.NRow.TClassName<RecordType>;
+    tableLayout?: NTable.TLayout;
+    showHeader?: boolean;
+    sticky?: boolean | NTable.NSticky.ISticky;
+    loading?: boolean;
+    hovered?: boolean;
+    bordered?: boolean;
+    borderless?: boolean;
+    header?: NTable.NRender.TPanelRender<RecordType>;
+    footer?: NTable.NRender.TPanelRender<RecordType>;
+    components?: NTable.NCustomize.TableComponents<RecordType>;
+    customRow?: NTable.NCustomize.TGetComponentProps<RecordType>;
+    customHeaderRow?: NTable.NCustomize.TGetComponentProps<NTable.NColumn.IColumn<RecordType>[]>;
+    pagination?: false | NTable.NPagination.IProps;
+    scroll?: NTable.TScroll;
+    sortDirections?: NTable.TSortOrder[];
+    showSorterTooltip?: boolean | ComponentProps<typeof CdsTooltip>;
+    expandFixed?: NTable.TFixed;
+    expandColumnWidth?: number;
+    expandedRowKeys?: NTable.TKey[];
+    expandIconColumnIndex?: number;
+    rowSelection?: NTable.NRow.IRowSelection<RecordType>;
+    defaultExpandedRowKeys?: NTable.TKey[];
+    defaultExpandAllRows?: boolean;
+    canExpandable?: boolean;
+    expandedRowRender?: NTable.NExpand.TExpandedRowRender<RecordType>;
+    expandRowByClick?: boolean;
+    expandIcon?: NTable.NExpand.TRenderExpandIcon<RecordType>;
+    indentSize: number;
+    showExpandColumn?: boolean;
+    expandedRowClassName?: NTable.NRow.TClassName<RecordType>;
+    childrenColumnName?: string;
+    rowExpandable?: NTable.NExpand.IExpandable['rowExpandable'];
+    transformCellText?: NTable.NCell.TTransformCellText<RecordType>;
+    getPopupContainer?: NTable.NCustomize.TGetPopupContainer;
+    onChange?: (pagination: NTable.NPagination.IProps, filters: Record<string, NTable.TFilterValue | null>, sorter: NTable.ISorterResult | NTable.ISorterResult[], extra: NTable.ICurrentData) => void;
+    onExpand?: (expanded: boolean, record: RecordType) => void;
+    onExpandedRowsChange?: (expandedKeys: NTable.TKey[]) => void;
+    onResizeColumn?: (width: number, column: NTable.NColumn.IColumn<RecordType>) => void;
+    /**
+     * @private Internal usage, may remove by refactor. Should always use `columns` instead.
+     *
+     * !!! DO NOT USE IN PRODUCTION ENVIRONMENT !!!
+     */
+    internalHooks?: string;
+    /**
+     * @private Internal usage, may remove by refactor. Should always use `columns` instead.
+     *
+     * !!! DO NOT USE IN PRODUCTION ENVIRONMENT !!!
+     */
+    transformColumns?: (columns: NTable.NColumn.TColumns<RecordType>) => NTable.NColumn.TColumns<RecordType>;
+    /**
+     * @private Internal usage, may remove by refactor.
+     *
+     * !!! DO NOT USE IN PRODUCTION ENVIRONMENT !!!
+     */
+    internalRefs?: {
+        body: HTMLDivElement | null;
+    };
+    /**
+     * @private Internal usage, may remove by refactor.
+     *
+     * !!! DO NOT USE IN PRODUCTION ENVIRONMENT !!!
+     */
+    onUpdateInternalRefs?: (refs: Record<string, any>) => void;
+}
+export declare const makeTableProps: <Defaults extends {
+    id?: unknown;
+    data?: unknown;
+    columns?: unknown;
+    rowKey?: unknown;
+    rowClassName?: unknown;
+    tableLayout?: unknown;
+    showHeader?: unknown;
+    sticky?: unknown;
+    loading?: unknown;
+    hovered?: unknown;
+    bordered?: unknown;
+    borderless?: unknown;
+    header?: unknown;
+    footer?: unknown;
+    components?: unknown;
+    customRow?: unknown;
+    customHeaderRow?: unknown;
+    pagination?: unknown;
+    scroll?: unknown;
+    sortDirection?: unknown;
+    showSorterTooltip?: unknown;
+    expandFixed?: unknown;
+    expandColumnWidth?: unknown;
+    expandedRowKeys?: unknown;
+    rowSelection?: unknown;
+    defaultExpandedRowKeys?: unknown;
+    defaultExpandAllRows?: unknown;
+    canExpandable?: unknown;
+    expandedRowRender?: unknown;
+    expandRowByClick?: unknown;
+    expandIconColumnIndex?: unknown;
+    expandIcon?: unknown;
+    indentSize?: unknown;
+    showExpandColumn?: unknown;
+    expandedRowClassName?: unknown;
+    childrenColumnName?: unknown;
+    rowExpandable?: unknown;
+    transformCellText?: unknown;
+    getPopupContainer?: unknown;
+    onChange?: unknown;
+    onResizeColumn?: unknown;
+} = {}>(defaults?: Defaults | undefined) => import('../../../utils').AppendDefault<{
+    /**
+     * Идентификатор таблицы
+     */
+    id: {
+        type: PropType<string>;
+        default: undefined;
+    };
+    /**
+     * Массив данных для отображения в таблице
+     */
+    data: {
+        type: PropType<any[]>;
+        default: undefined;
+    };
+    /**
+     * Колонки таблицы
+     */
+    columns: {
+        type: PropType<NTable.NColumn.TColumns<any>>;
+        default: undefined;
+    };
+    /**
+     * Уникальный ключ строки может быть строкой или функцией возвращающей строку
+     */
+    rowKey: {
+        type: PropType<string | NTable.NRow.TGetRowKey<any>>;
+        default: string;
+    };
+    /**
+     * Классы строки
+     */
+    rowClassName: {
+        type: PropType<string | NTable.NRow.TClassName<any>>;
+        default: undefined;
+    };
+    /**
+     * Фиксированный или авто лэйаут
+     */
+    tableLayout: {
+        type: PropType<NTable.TLayout>;
+        default: undefined;
+    };
+    /**
+     * Показывать ли заголовок таблицы
+     */
+    showHeader: {
+        type: PropType<boolean>;
+        default: undefined;
+    };
+    /**
+     * Sticky для заголовка и скроллбара
+     */
+    sticky: {
+        type: PropType<boolean | NTable.NSticky.ISticky>;
+        default: undefined;
+    };
+    /**
+     * Загрузка таблицы
+     */
+    loading: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Подсвечивание строки при наведении
+     */
+    hovered: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Показывать все границы таблицы
+     */
+    bordered: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Убрать все границы таблицы
+     */
+    borderless: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Рендер заголовка таблицы
+     */
+    header: {
+        type: PropType<NTable.NRender.TPanelRender<any>>;
+        default: undefined;
+    };
+    /**
+     * Рендер футера таблицы
+     */
+    footer: {
+        type: PropType<NTable.NRender.TPanelRender<any>>;
+        default: undefined;
+    };
+    /**
+     * Переопределить компоненты таблицы по умолчанию
+     */
+    components: {
+        type: PropType<NTable.NCustomize.TableComponents<any>>;
+        default: undefined;
+    };
+    /**
+     * Устанавливает свойства для каждой строки
+     */
+    customRow: {
+        type: PropType<NTable.NCustomize.TGetComponentProps<any>>;
+        default: undefined;
+    };
+    /**
+     * Устанавливает свойства для каждой строки заголовка
+     */
+    customHeaderRow: {
+        type: PropType<NTable.NCustomize.TGetComponentProps<NTable.NColumn.IColumn<any>[]>>;
+        default: undefined;
+    };
+    /**
+     * Конфигурация пагинации таблицы
+     */
+    pagination: {
+        type: PropType<false | NTable.NPagination.IProps>;
+        default: undefined;
+    };
+    /**
+     * Можно ли скроллить таблицу
+     */
+    scroll: {
+        type: PropType<NTable.TScroll & {
+            scrollToFirstRowOnChange?: boolean | undefined;
+        }>;
+        default: undefined;
+    };
+    /**
+     * Сортировка данных в таблице. 'ascend' | 'descend'
+     */
+    sortDirection: {
+        type: PropType<string[]>;
+        default: undefined;
+    };
+    /**
+     * Показывать ли тултипы для сортировки в заголовке. Можно передать объект со свойствами для CdsTooltip.
+     */
+    showSorterTooltip: {
+        type: PropType<boolean | Omit<Partial<{
+            text: string;
+            disabled: boolean;
+            location: NonNullable<import('../../../utils').TAnchor>;
+            transition: NonNullable<string | boolean | (import("vue").TransitionProps & {
+                component?: import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions> | undefined;
+            })>;
+            origin: NonNullable<import('../../../utils').TAnchor | "auto" | "overlap">;
+            id: string;
+            modelValue: boolean;
+            attach: string | boolean | Element;
+            contained: boolean;
+            persistent: boolean;
+            scrim: NonNullable<string | boolean>;
+            closeOnBack: boolean;
+            zIndex: string | number;
+            contentClasses: string | string[] | Record<string, boolean>;
+            contentProps: Record<string, unknown>;
+            activator: string | import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | Element;
+            activatorProps: Record<string, any>;
+            openOnClick: NonNullable<boolean | undefined>;
+            openOnHover: boolean;
+            openOnFocus: boolean | undefined;
+            closeOnContentClick: boolean;
+            closeDelay: string | number;
+            openDelay: string | number;
+            locationStrategy: NonNullable<"static" | "connected" | ((data: import("../../CdsOverlay/composable").ILocationStrategyData, props: import("../../CdsOverlay/composable").ILocationStrategyProps, contentStyles: Ref<Record<string, string>>) => {
+                updateLocation: (event: Event) => void;
+            } | undefined)>;
+            offset: NonNullable<string | number | number[]>;
+            scrollStrategy: NonNullable<"none" | "close" | "block" | "reposition" | ((data: import("../../CdsOverlay/composable").IScrollStrategyData, props: import("../../CdsOverlay/composable").IScrollStrategyProps, scope: import("vue").EffectScope) => void)>;
+            eager: boolean;
+            height: string | number;
+            width: string | number;
+            maxHeight: string | number;
+            maxWidth: string | number;
+            minHeight: string | number;
+            minWidth: NonNullable<string | number>;
+            hideArrow: boolean;
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            closeDelay: {
+                type: PropType<string | number>;
+                default: null;
+            };
+            openDelay: {
+                type: PropType<string | number>;
+                default: null;
+            };
+            transition: Omit<{
+                type: PropType<string | boolean | (import("vue").TransitionProps & {
+                    component?: import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions> | undefined;
+                })>;
+                default: string;
+                validator: (value: unknown) => boolean;
+            }, "default" | "type"> & {
+                type: PropType<NonNullable<string | boolean | (import("vue").TransitionProps & {
+                    component?: import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions> | undefined;
+                })>>;
+                default: NonNullable<string | boolean | (import("vue").TransitionProps & {
+                    component?: import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions> | undefined;
+                })>;
+            };
+            height: {
+                type: PropType<string | number>;
+                default: string;
+            };
+            width: {
+                type: PropType<string | number>;
+                default: string;
+            };
+            maxHeight: {
+                type: PropType<string | number>;
+                default: string;
+            };
+            maxWidth: {
+                type: PropType<string | number>;
+                default: string;
+            };
+            minHeight: {
+                type: PropType<string | number>;
+                default: string;
+            };
+            minWidth: Omit<{
+                type: PropType<string | number>;
+                default: string;
+            }, "default" | "type"> & {
+                type: PropType<NonNullable<string | number>>;
+                default: NonNullable<string | number>;
+            };
+            eager: Omit<{
+                type: PropType<boolean>;
+                default: boolean;
+            }, "default" | "type"> & {
+                type: PropType<boolean>;
+                default: boolean;
+            };
+            scrollStrategy: Omit<{
+                type: PropType<"none" | "close" | "block" | "reposition" | ((data: import("../../CdsOverlay/composable").IScrollStrategyData, props: import("../../CdsOverlay/composable").IScrollStrategyProps, scope: import("vue").EffectScope) => void)>;
+                default: string;
+                validator: (value: any) => boolean;
+            }, "default" | "type"> & {
+                type: PropType<NonNullable<"none" | "close" | "block" | "reposition" | ((data: import("../../CdsOverlay/composable").IScrollStrategyData, props: import("../../CdsOverlay/composable").IScrollStrategyProps, scope: import("vue").EffectScope) => void)>>;
+                default: NonNullable<"none" | "close" | "block" | "reposition" | ((data: import("../../CdsOverlay/composable").IScrollStrategyData, props: import("../../CdsOverlay/composable").IScrollStrategyProps, scope: import("vue").EffectScope) => void)>;
+            };
+            locationStrategy: Omit<{
+                type: PropType<"static" | "connected" | ((data: import("../../CdsOverlay/composable").ILocationStrategyData, props: import("../../CdsOverlay/composable").ILocationStrategyProps, contentStyles: Ref<Record<string, string>>) => {
+                    updateLocation: (event: Event) => void;
+                } | undefined)>;
+                default: string;
+                validator: (value: any) => boolean;
+            }, "default" | "type"> & {
+                type: PropType<NonNullable<"static" | "connected" | ((data: import("../../CdsOverlay/composable").ILocationStrategyData, props: import("../../CdsOverlay/composable").ILocationStrategyProps, contentStyles: Ref<Record<string, string>>) => {
+                    updateLocation: (event: Event) => void;
+                } | undefined)>>;
+                default: NonNullable<"static" | "connected" | ((data: import("../../CdsOverlay/composable").ILocationStrategyData, props: import("../../CdsOverlay/composable").ILocationStrategyProps, contentStyles: Ref<Record<string, string>>) => {
+                    updateLocation: (event: Event) => void;
+                } | undefined)>;
+            };
+            location: Omit<{
+                type: PropType<import('../../../utils').TAnchor>;
+                default: string;
+            }, "default" | "type"> & {
+                type: PropType<NonNullable<import('../../../utils').TAnchor>>;
+                default: NonNullable<import('../../../utils').TAnchor>;
+            };
+            origin: Omit<{
+                type: PropType<import('../../../utils').TAnchor | "auto" | "overlap">;
+                default: string;
+            }, "default" | "type"> & {
+                type: PropType<NonNullable<import('../../../utils').TAnchor | "auto" | "overlap">>;
+                default: NonNullable<import('../../../utils').TAnchor | "auto" | "overlap">;
+            };
+            offset: Omit<{
+                type: PropType<string | number | number[]>;
+                default: null;
+            }, "default" | "type"> & {
+                type: PropType<NonNullable<string | number | number[]>>;
+                default: NonNullable<string | number | number[]>;
+            };
+            activator: {
+                type: PropType<string | import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | Element>;
+                default: null;
+            };
+            activatorProps: {
+                type: PropType<Record<string, any>>;
+                default: () => {};
+            };
+            openOnClick: Omit<{
+                type: PropType<boolean | undefined>;
+                default: undefined;
+            }, "default" | "type"> & {
+                type: PropType<NonNullable<boolean | undefined>>;
+                default: NonNullable<boolean | undefined>;
+            };
+            openOnHover: Omit<{
+                type: PropType<boolean>;
+                default: boolean;
+            }, "default" | "type"> & {
+                type: PropType<boolean>;
+                default: boolean;
+            };
+            openOnFocus: {
+                type: PropType<boolean | undefined>;
+                default: undefined;
+            };
+            closeOnContentClick: {
+                type: PropType<boolean>;
+                default: boolean;
+            };
+            attach: {
+                type: PropType<string | boolean | Element>;
+                default: boolean;
+            };
+            contained: {
+                type: PropType<boolean>;
+                default: boolean;
+            };
+            disabled: {
+                type: PropType<boolean>;
+                default: boolean;
+            };
+            persistent: {
+                type: PropType<boolean>;
+                default: boolean;
+            };
+            scrim: Omit<{
+                type: PropType<string | boolean>;
+                default: boolean;
+            }, "default" | "type"> & {
+                type: PropType<NonNullable<string | boolean>>;
+                default: NonNullable<string | boolean>;
+            };
+            modelValue: {
+                type: PropType<boolean>;
+                default: boolean;
+            };
+            closeOnBack: Omit<{
+                type: PropType<boolean>;
+                default: boolean;
+            }, "default" | "type"> & {
+                type: PropType<boolean>;
+                default: boolean;
+            };
+            zIndex: {
+                type: PropType<string | number>;
+                default: number;
+            };
+            contentClasses: {
+                type: PropType<string | string[] | Record<string, boolean>>;
+                default: null;
+            };
+            contentProps: {
+                type: PropType<Record<string, unknown>>;
+                default: () => {};
+            };
+            text: {
+                type: PropType<string>;
+                default: undefined;
+            };
+            id: {
+                type: PropType<string>;
+                default: undefined;
+            };
+            hideArrow: {
+                type: PropType<boolean>;
+                default: boolean;
+            };
+        }>> & {
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "text" | "disabled" | "location" | "transition" | "origin" | "id" | "modelValue" | "attach" | "contained" | "persistent" | "scrim" | "closeOnBack" | "zIndex" | "contentClasses" | "contentProps" | "activator" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "closeDelay" | "openDelay" | "locationStrategy" | "offset" | "scrollStrategy" | "eager" | "height" | "width" | "maxHeight" | "maxWidth" | "minHeight" | "minWidth" | "hideArrow">, keyof import("vue").VNodeProps | keyof import("vue").AllowedComponentProps>>;
+        default: boolean;
+    };
+    /**
+     * Сделать колонку с раскрытием фиксированной (left | right | boolean)
+     */
+    expandFixed: {
+        type: PropType<NTable.TFixed>;
+        default: undefined;
+    };
+    /**
+     * Ширина колонки с раскрытием
+     */
+    expandColumnWidth: {
+        type: PropType<number>;
+        default: undefined;
+    };
+    /**
+     * Ключи текущих раскрытых строк (поддерживает v-model)
+     */
+    expandedRowKeys: {
+        type: PropType<NTable.TKey[]>;
+        default: NTable.TKey[] | undefined;
+    };
+    /**
+     * Конфигурация для выбора строк
+     */
+    rowSelection: {
+        type: PropType<NTable.NRow.IRowSelection<any>>;
+        default: undefined;
+    };
+    /**
+     * Ключи раскрытых строк по умолчанию
+     */
+    defaultExpandedRowKeys: {
+        type: PropType<NTable.TKey[]>;
+        default: NTable.TKey[] | undefined;
+    };
+    /**
+     * По умолчанию все колонки раскрыты
+     */
+    defaultExpandAllRows: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Может раскрываться
+     */
+    canExpandable: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Рендер для каждой раскрытой строки
+     */
+    expandedRowRender: {
+        type: PropType<NTable.NExpand.TExpandedRowRender<any>>;
+        default: undefined;
+    };
+    /**
+     * Раскрытие строки по клику в любое место этой строки
+     */
+    expandRowByClick: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Индекс колонки, в которой будет располагаться иконка раскрытия
+     */
+    expandIconColumnIndex: {
+        type: PropType<number>;
+        default: undefined;
+    };
+    /**
+     * Своя иконка раскрытия
+     */
+    expandIcon: {
+        type: PropType<NTable.NExpand.TRenderExpandIcon<any>>;
+        default: undefined;
+    };
+    /**
+     * Размер отступа в пикселях для каждого уровня вложенности
+     */
+    indentSize: {
+        type: PropType<number>;
+        default: number;
+    };
+    /**
+     * Показать раскрытую колонку
+     */
+    showExpandColumn: {
+        type: PropType<boolean>;
+        default: undefined;
+    };
+    /**
+     * Классы для строк в раскрытом состоянии
+     */
+    expandedRowClassName: {
+        type: PropType<NTable.NRow.TClassName<any>>;
+        default: undefined;
+    };
+    /**
+     * Названия свойства для дочерних элементов
+     */
+    childrenColumnName: {
+        type: PropType<string>;
+        default: string;
+    };
+    /**
+     * Строку можно раскрыть
+     */
+    rowExpandable: {
+        type: PropType<((record: any) => boolean) | undefined>;
+        default: undefined;
+    };
+    /**
+     * Трансформировать текст в ячейке
+     */
+    transformCellText: {
+        type: PropType<NTable.NCell.TTransformCellText<any>>;
+        default: undefined;
+    };
+    /**
+     * Контейнер рендеринга выпадающих списков
+     */
+    getPopupContainer: {
+        type: PropType<NTable.NCustomize.TGetPopupContainer>;
+        default: undefined;
+    };
+    /**
+     * Событие при изменении пагинации, фильтров, сортировки
+     */
+    onChange: {
+        type: PropType<(pagination: NTable.NPagination.IProps, filters: Record<string, NTable.TFilterValue | null>, sorters: NTable.ISorterResult | NTable.ISorterResult[], extra: NTable.ICurrentData) => void>;
+        default: undefined;
+    };
+    /**
+     * Событие изменения размера колонки
+     */
+    onResizeColumn: {
+        type: PropType<(width: number, column: NTable.NColumn.IColumn) => void>;
+        default: undefined;
+    };
+}, Defaults>;
+export declare function useLazyKVMap<RecordType>(dataRef: Ref<readonly RecordType[]>, childrenColumnNameRef: Ref<string>, getRowKeyRef: Ref<NTable.NRow.TGetRowKey<RecordType>>): {
+    getRecordByKey: (key: NTable.TKey) => NonNullable<RecordType>;
+};

package/dist/components/CdsTable/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const INTERNAL_COL_DEFINE = "CDS_TABLE_INTERNAL_COL_DEFINE";
+export declare const INTERNAL_HOOKS = "CDS_TABLE_INTERNAL_HOOK";

package/dist/components/CdsTable/context/body.d.ts

@@ -0,0 +1,19 @@
+import type { NTable } from '../interface';
+import type { InjectionKey } from 'vue';
+export interface IBodyContextProps<RecordType = NTable.TDefaultRecord> {
+    rowClassName?: string | NTable.NRow.TClassName<RecordType>;
+    expandedRowClassName?: NTable.NRow.TClassName<RecordType>;
+    columns: NTable.NColumn.TColumns<RecordType>;
+    flattenColumns: readonly NTable.NColumn.IColumn<RecordType>[];
+    tableLayout: NTable.TLayout;
+    indentSize: number;
+    expandableType: NTable.NExpand.TExpandableType;
+    expandRowByClick?: boolean;
+    expandedRowRender?: NTable.NExpand.TExpandedRowRender<RecordType>;
+    expandIconColumnIndex?: number;
+    expandIcon: NTable.NExpand.TRenderExpandIcon<RecordType>;
+    onTriggerExpand: NTable.TTriggerEventHandler<RecordType>;
+}
+export declare const BodyContextKey: InjectionKey<IBodyContextProps>;
+export declare const useProvideBody: (props: IBodyContextProps) => void;
+export declare const useInjectBody: () => IBodyContextProps<any>;

package/dist/components/CdsTable/context/expandedRow.d.ts

@@ -0,0 +1,10 @@
+import type { InjectionKey, Ref, ComputedRef } from 'vue';
+export interface IExpandRowProps {
+    componentWidth: Ref<number>;
+    fixHeader: ComputedRef<boolean | undefined>;
+    fixColumn: Ref<boolean>;
+    horizonScroll: Ref<boolean>;
+}
+export declare const ExpandedRowContextKey: InjectionKey<IExpandRowProps>;
+export declare const useProvideExpandedRow: (props: IExpandRowProps) => void;
+export declare const useInjectExpandedRow: () => IExpandRowProps;

package/dist/components/CdsTable/context/hover.d.ts

@@ -0,0 +1,9 @@
+import type { InjectionKey, Ref } from 'vue';
+export interface IHoverContextProps {
+    startRow: Ref<number>;
+    endRow: Ref<number>;
+    onHover: (start?: number, end?: number) => void;
+}
+export declare const HoverContextKey: InjectionKey<IHoverContextProps>;
+export declare const useProvideHover: (props: IHoverContextProps) => void;
+export declare const useInjectHover: () => IHoverContextProps;