cnhis-design-vue 3.1.22-beta.9 → 3.1.23-beta.0

package/es/components/iho-table/src/plugins/rendererPlugins/editableWidgets/separateRendererPlugin/index.js

@@ -0,0 +1,158 @@
+import { reactive, inject, unref, createVNode, onBeforeUnmount } from 'vue';
+import { traverse } from '../../../../../../../shared/utils/index2.js';
+import { isFunction } from 'lodash-es';
+import '../../../../../index2.js';
+import { INPUT_TYPE, InjectionIhoTableUUID } from '../../../../constants/index2.js';
+import { getRowHeight } from '../../../../utils/index2.js';
+import { isSeparateColumn, getColumnRenderWidth, contentSeparate, getColumnInfoMaxLength, generateSeparateRowData } from './separate-utils2.js';
+import EditSeparate from './edit-separate.js';
+import { defineTablePlugin } from '../../../../hooks/useTablePlugin2.js';
+
+function separateRendererPlugins() {
+  const pluginName = "separateRendererPlugins";
+  const separateRowMap = reactive(/* @__PURE__ */ new Map());
+  function getSeparateRowData(uuid, rowData) {
+    var _a;
+    return (_a = separateRowMap.get(uuid)) == null ? void 0 : _a.get(rowData);
+  }
+  function setSeparateRowData(uuid, rowData, data) {
+    const map = separateRowMap.get(uuid) || /* @__PURE__ */ new WeakMap();
+    separateRowMap.set(uuid, map);
+    map.set(rowData, data);
+  }
+  const separateColumnMap = reactive(/* @__PURE__ */ new Map());
+  return defineTablePlugin({
+    name: pluginName,
+    vxe(instance) {
+      instance.renderer.add(INPUT_TYPE.SEPARATE, {
+        renderCell(renderOpt, {
+          column,
+          row
+        }) {
+          var _a;
+          const uuid = inject(InjectionIhoTableUUID);
+          const separateRow = getSeparateRowData(unref(uuid), row);
+          return createVNode("section", null, [(_a = separateRow == null ? void 0 : separateRow.separateData) == null ? void 0 : _a[column.field]]);
+        },
+        renderEdit(renderOpt, {
+          column,
+          row
+        }) {
+          var _a;
+          const uuid = inject(InjectionIhoTableUUID);
+          const separateRow = getSeparateRowData(unref(uuid), row);
+          const height = getRowHeight();
+          return [createVNode(EditSeparate, {
+            "value": row[column.field],
+            "onUpdate:value": ($event) => row[column.field] = $event,
+            "dataIndex": separateRow == null ? void 0 : separateRow.index,
+            "height": height,
+            "column": column,
+            "row": row,
+            "displayContent": (_a = separateRow == null ? void 0 : separateRow.separateData) == null ? void 0 : _a[column.field]
+          }, null)];
+        }
+      });
+    },
+    apply(hooks) {
+      hooks.fieldHooks.fieldList.tap(pluginName, (fieldList, {
+        uuid
+      }) => {
+        uuid && separateColumnMap.set(uuid, getSeparateColumn(fieldList));
+        return fieldList;
+        function getSeparateColumn(fieldList2) {
+          return fieldList2.reduce((res, field) => {
+            traverse(field, (item) => {
+              isSeparateColumn(item) && res.push(item);
+            });
+            return res;
+          }, []);
+        }
+      });
+      hooks.dataHooks.data.tapPromise(pluginName, async (rowData, {
+        insertAfter,
+        index: dataIndex,
+        $table
+      }, config) => {
+        if (!config.uuid)
+          return;
+        const separateColumns = separateColumnMap.get(config.uuid);
+        if (!separateColumns || !separateColumns.length)
+          return;
+        const parsedRowDataInfo = [];
+        for (const column of separateColumns) {
+          if (!column.field)
+            continue;
+          const width = await getColumnRenderWidth(column, $table);
+          parsedRowDataInfo.push({
+            field: column.field,
+            data: contentSeparate(rowData[column.field], column, width)
+          });
+        }
+        Array.from({
+          length: getColumnInfoMaxLength(parsedRowDataInfo)
+        }).forEach((_, index) => {
+          const separateData = generateSeparateRowData(parsedRowDataInfo, index);
+          if (index === 0) {
+            setSeparateRowData(config.uuid, rowData, {
+              index: dataIndex,
+              separateData
+            });
+            rowData.$__SEPARATE_DATA = [separateData];
+            return;
+          }
+          const data = {
+            $__SEPARATE: true
+          };
+          setSeparateRowData(config.uuid, data, {
+            index: dataIndex,
+            separateData
+          });
+          rowData.$__SEPARATE_DATA.push(separateData);
+          insertAfter(data);
+        });
+      });
+      hooks.eventHooks.onResizableChange.tap(pluginName, async ({
+        column
+      }, context) => {
+        if (!isSeparateColumn(column))
+          return;
+        context.updateTableDataRef();
+      });
+      hooks.configHooks.editConfig.tap(pluginName, (editConfig = {}, config) => {
+        editConfig.activeMethod = avoidOperationDecorator(editConfig.activeMethod);
+        return editConfig;
+      });
+      hooks.configHooks.checkboxConfig.tap(pluginName, (checkboxConfig = {}, config) => {
+        checkboxConfig.checkMethod = avoidOperationDecorator(checkboxConfig.checkMethod);
+        checkboxConfig.visibleMethod = avoidOperationDecorator(checkboxConfig.visibleMethod);
+        return checkboxConfig;
+      });
+      function avoidOperationDecorator(oldFn) {
+        return (...args) => {
+          var _a;
+          if ((_a = args[0].row) == null ? void 0 : _a.$__SEPARATE)
+            return false;
+          if (isFunction(oldFn)) {
+            return oldFn(...args);
+          }
+          return true;
+        };
+      }
+      hooks.setupHooks.setup.tap(pluginName, (config) => {
+        if (config.value.uuid) {
+          separateRowMap.set(config.value.uuid, /* @__PURE__ */ new WeakMap());
+          separateColumnMap.set(config.value.uuid, []);
+        }
+        onBeforeUnmount(() => {
+          if (config.value.uuid) {
+            separateRowMap.delete(config.value.uuid);
+            separateColumnMap.delete(config.value.uuid);
+          }
+        });
+      });
+    }
+  });
+}
+
+export { separateRendererPlugins };

package/es/components/iho-table/src/plugins/rendererPlugins/editableWidgets/separateRendererPlugin/separate-utils.d.ts

@@ -0,0 +1,14 @@
+import { AnyObject, Nullable } from '../../../../../../../../es/shared/types';
+import { MaybeRef } from '@vueuse/core';
+import { VxeTableDefines, VxeTableInstance } from 'vxe-table';
+import { IhoTableFieldItem } from '../../../../../../../../es/components/iho-table';
+declare type ParsedRowDataInfo = {
+    field: string;
+    data: string[];
+};
+export declare function getColumnInfoMaxLength(parsedRowDataInfo: ParsedRowDataInfo[]): number;
+export declare function getColumnRenderWidth(column: AnyObject, $table: MaybeRef<Nullable<VxeTableInstance>>): Promise<number>;
+export declare function generateSeparateRowData(parsedRowDataInfo: ParsedRowDataInfo[], index: number): AnyObject;
+export declare function contentSeparate(value: unknown, field: IhoTableFieldItem, width: number): any[];
+export declare function isSeparateColumn(field: IhoTableFieldItem | VxeTableDefines.ColumnInfo): boolean | "" | undefined;
+export {};

package/es/components/iho-table/src/plugins/rendererPlugins/editableWidgets/separateRendererPlugin/separate-utils.js

@@ -0,0 +1 @@
+export { contentSeparate, generateSeparateRowData, getColumnInfoMaxLength, getColumnRenderWidth, isSeparateColumn } from './separate-utils2.js';

package/es/components/iho-table/src/plugins/rendererPlugins/editableWidgets/separateRendererPlugin/separate-utils2.js

@@ -0,0 +1,54 @@
+import { getStringWidth } from '../../../../../../../shared/utils/index2.js';
+import { isNumber, isArray, cloneDeep, isString } from 'lodash-es';
+import { nextTick, unref } from 'vue';
+import { INPUT_TYPE } from '../../../../constants/index2.js';
+
+function getColumnInfoMaxLength(parsedRowDataInfo) {
+  return Math.max(...parsedRowDataInfo.map((r) => r.data.length), 1);
+}
+async function getColumnRenderWidth(column, $table) {
+  const prev = getRenderWidth();
+  if (!prev) {
+    await nextTick();
+  }
+  return getRenderWidth() || getColumnWidth();
+  function getRenderWidth() {
+    var _a, _b;
+    return (_b = (_a = unref($table)) == null ? void 0 : _a.getColumnByField(column.field)) == null ? void 0 : _b.renderWidth;
+  }
+  function getColumnWidth() {
+    return isNumber(column.width) ? column.width : 64;
+  }
+}
+function generateSeparateRowData(parsedRowDataInfo, index) {
+  return parsedRowDataInfo.reduce((res, info) => {
+    res[info.field] = info.data[index];
+    return res;
+  }, {});
+}
+function contentSeparate(value, field, width) {
+  if (isArray(value)) {
+    return value.map((row) => {
+      var _a, _b, _c;
+      return (_c = (_b = (_a = field.context) == null ? void 0 : _a.separateFormatter) == null ? void 0 : _b.call(_a, cloneDeep(row))) != null ? _c : row;
+    });
+  }
+  if (!isString(value) || !isNumber(width))
+    return [value];
+  width -= 24;
+  return [...value].reduce((res, char) => {
+    const latestString = res[res.length - 1];
+    if (getStringWidth(latestString + char) > width) {
+      res.push(char);
+    } else {
+      res[res.length - 1] = latestString + char;
+    }
+    return res;
+  }, [""]);
+}
+function isSeparateColumn(field) {
+  var _a;
+  return field.field && ((_a = field.editRender) == null ? void 0 : _a.name) === INPUT_TYPE.SEPARATE;
+}
+
+export { contentSeparate, generateSeparateRowData, getColumnInfoMaxLength, getColumnRenderWidth, isSeparateColumn };

package/es/components/iho-table/src/plugins/rendererPlugins/index.d.ts

@@ -1,2 +1,2 @@
 export * from './widgets';
-export * from './inputs';
+export * from './editableWidgets';

package/es/components/iho-table/src/plugins/rendererPlugins/index.js

@@ -4,4 +4,5 @@ export { colorRendererPlugin } from './widgets/colorRendererPlugin.js';
 export { seqRendererPlugin } from './widgets/seqRendererPlugin.js';
 export { checkRendererPlugin } from './widgets/checkRendererPlugin.js';
 export { pictureRendererPlugin } from './widgets/pictureRendererPlugin.js';
-export { inputRendererPlugins } from './inputs/inputRendererPlugins.js';
+export { inputRendererPlugins } from './editableWidgets/inputRendererPlugins.js';
+export { separateRendererPlugins } from './editableWidgets/separateRendererPlugin/index.js';

package/es/components/iho-table/src/plugins/rendererPlugins/widgets/pictureRendererPlugin.js

@@ -1,4 +1,4 @@
-import { defineComponent, watch, createVNode } from 'vue';
+import { defineComponent, watch, onBeforeUnmount, createVNode } from 'vue';
 import { arrayed } from '../../../../../../shared/utils/index2.js';
 import '../../../../index2.js';
 import { WIDGET_TYPE } from '../../../constants/index2.js';
@@ -77,6 +77,7 @@ const ViewerImage = defineComponent({
     }, {
       deep: true
     });
+    onBeforeUnmount(() => $viewer == null ? void 0 : $viewer.destroy());
     return () => createVNode("img", {
       "style": "cursor:pointer",
       "alt": "",

package/es/components/iho-table/src/types/index.d.ts

@@ -13,6 +13,7 @@ declare type GetUnionLast<U> = UnionToIntersectionFn<U> extends () => infer I ?
 declare type Prepend<Tuple extends unknown[], First> = [First, ...Tuple];
 export declare type UnionToTuple<Union, T extends unknown[] = [], Last = GetUnionLast<Union>> = [Union] extends [never] ? T : UnionToTuple<Exclude<Union, Last>, Prepend<T, Last>>;
 export declare type IhoTableConfig = VxeTableProps & Partial<{
+    uuid: string;
     showSeq: boolean;
     selectType: Exclude<VxeTableDefines.ColumnInfo['type'], 'seq' | 'expand' | 'html'>;
     rowGroupSetting: Partial<Record<TupleToUnion<typeof IhoTableRowGroupSequence>, IhoTableRowGroupItem[]>>;
@@ -20,6 +21,8 @@ export declare type IhoTableConfig = VxeTableProps & Partial<{
 }>;
 export declare type IhoTableFieldItem = {
     [K in keyof VxeTableDefines.ColumnInfo]?: K extends 'children' ? IhoTableFieldItem[] : K extends keyof VxeTableDefines.ColumnInfo ? VxeTableDefines.ColumnInfo[K] : never;
+} & {
+    context?: AnyObject;
 } & {
     [K: string]: unknown;
 };
@@ -32,10 +35,11 @@ export declare type LowCodeTableFieldItem = {
     columnName: string;
     [K: string]: unknown;
 } & Partial<{
-    id?: number | string;
-    title?: string;
-    colWidth?: string | number;
+    id: number | string;
+    title: string;
+    colWidth: string | number;
     settingObj: LowCodeTableSettingObj;
+    context: AnyObject;
 }>;
 export declare type IhoFormChangePayload = {
     column: VxeTableDefines.ColumnInfo;
@@ -44,3 +48,4 @@ export declare type IhoFormChangePayload = {
     index: number;
 };
 export declare type EventListenerToEventName<T extends string> = T extends `on${infer R}` ? R extends `${infer F}${infer L}` ? `${Lowercase<F>}${L}` : never : never;
+export declare type IhoTableHandler = Record<'updateConfigRef' | 'updateFieldListRef' | 'updateTableDataRef', () => void>;

package/es/components/iho-table/src/types/index.js

@@ -1 +1 @@
-export { AbstractConfigHooks, AbstractEventHooks, AbstractFieldHooks } from './pluginType2.js';
+export { AbstractConfigHooks, AbstractDataHooks, AbstractEventHooks, AbstractFieldHooks, AbstractSetupHooks } from './pluginType2.js';

package/es/components/iho-table/src/types/pluginType.d.ts

@@ -1,9 +1,11 @@
-import { ArrayAble, Nullable } from '../../../../../es/shared/types';
-import { AsyncParallelHook, SyncWaterfallHook } from '../../../../../es/shared/utils/tapable';
+import { AnyObject, ArrayAble, Func, NotNull, Nullable } from '../../../../../es/shared/types';
+import { AsyncParallelHook, AsyncSeriesHook, SyncHook, SyncWaterfallHook } from '../../../../../es/shared/utils/tapable';
+import { MaybeRef } from '@vueuse/core';
+import { Ref } from 'vue';
 import { VxeGlobalCommands, VxeGlobalFormats, VxeGlobalHooks, VxeGlobalMenus, VxeGlobalRenderer, VxeTableInstance } from 'vxe-table';
 import { VxeTableEventProps, VxeTableEvents } from 'vxe-table/types/table';
 import { VxeGlobalInterceptor } from 'vxe-table/types/v-x-e-table';
-import { IhoTableConfig, IhoTableFieldItem } from '.';
+import { IhoTableConfig, IhoTableFieldItem, IhoTableHandler } from '.';
 export declare type IhoTableInstance = {
     interceptor: VxeGlobalInterceptor;
     renderer: VxeGlobalRenderer;
@@ -21,27 +23,30 @@ export declare type TableHooks = Readonly<{
     configHooks: AbstractConfigHooks;
     fieldHooks: AbstractFieldHooks;
     eventHooks: AbstractEventHooks;
+    dataHooks: AbstractDataHooks;
+    setupHooks: AbstractSetupHooks;
 }>;
 export declare type WithTableConfig<T = []> = T extends any[] ? [...T, IhoTableConfig] : [T, IhoTableConfig];
+declare type ConfigHookType<T> = SyncWaterfallHook<WithTableConfig<T>>;
 export declare abstract class AbstractConfigHooks {
     abstract readonly config: SyncWaterfallHook<IhoTableConfig>;
-    abstract readonly rowConfig: SyncWaterfallHook<WithTableConfig<IhoTableConfig['rowConfig']>>;
-    abstract readonly editConfig: SyncWaterfallHook<WithTableConfig<IhoTableConfig['editConfig']>>;
-    abstract readonly columnConfig: SyncWaterfallHook<WithTableConfig<IhoTableConfig['columnConfig']>>;
-    abstract readonly resizableConfig: SyncWaterfallHook<WithTableConfig<IhoTableConfig['resizableConfig']>>;
-    abstract readonly seqConfig: SyncWaterfallHook<WithTableConfig<IhoTableConfig['seqConfig']>>;
-    abstract readonly sortConfig: SyncWaterfallHook<WithTableConfig<IhoTableConfig['sortConfig']>>;
-    abstract readonly filterConfig: SyncWaterfallHook<WithTableConfig<IhoTableConfig['filterConfig']>>;
-    abstract readonly radioConfig: SyncWaterfallHook<WithTableConfig<IhoTableConfig['radioConfig']>>;
-    abstract readonly checkboxConfig: SyncWaterfallHook<WithTableConfig<IhoTableConfig['checkboxConfig']>>;
-    abstract readonly expandConfig: SyncWaterfallHook<WithTableConfig<IhoTableConfig['expandConfig']>>;
-    abstract readonly treeConfig: SyncWaterfallHook<WithTableConfig<IhoTableConfig['treeConfig']>>;
-    abstract readonly mouseConfig: SyncWaterfallHook<WithTableConfig<IhoTableConfig['mouseConfig']>>;
-    abstract readonly menuConfig: SyncWaterfallHook<WithTableConfig<IhoTableConfig['menuConfig']>>;
-    abstract readonly keyboardConfig: SyncWaterfallHook<WithTableConfig<IhoTableConfig['keyboardConfig']>>;
-    abstract readonly scrollY: SyncWaterfallHook<WithTableConfig<IhoTableConfig['scrollY']>>;
-    abstract readonly scrollX: SyncWaterfallHook<WithTableConfig<IhoTableConfig['scrollX']>>;
-    abstract readonly editRules: SyncWaterfallHook<WithTableConfig<IhoTableConfig['editRules']>>;
+    abstract readonly rowConfig: ConfigHookType<IhoTableConfig['rowConfig']>;
+    abstract readonly editConfig: ConfigHookType<IhoTableConfig['editConfig']>;
+    abstract readonly columnConfig: ConfigHookType<IhoTableConfig['columnConfig']>;
+    abstract readonly resizableConfig: ConfigHookType<IhoTableConfig['resizableConfig']>;
+    abstract readonly seqConfig: ConfigHookType<IhoTableConfig['seqConfig']>;
+    abstract readonly sortConfig: ConfigHookType<IhoTableConfig['sortConfig']>;
+    abstract readonly filterConfig: ConfigHookType<IhoTableConfig['filterConfig']>;
+    abstract readonly radioConfig: ConfigHookType<IhoTableConfig['radioConfig']>;
+    abstract readonly checkboxConfig: ConfigHookType<IhoTableConfig['checkboxConfig']>;
+    abstract readonly expandConfig: ConfigHookType<IhoTableConfig['expandConfig']>;
+    abstract readonly treeConfig: ConfigHookType<IhoTableConfig['treeConfig']>;
+    abstract readonly mouseConfig: ConfigHookType<IhoTableConfig['mouseConfig']>;
+    abstract readonly menuConfig: ConfigHookType<IhoTableConfig['menuConfig']>;
+    abstract readonly keyboardConfig: ConfigHookType<IhoTableConfig['keyboardConfig']>;
+    abstract readonly scrollY: ConfigHookType<IhoTableConfig['scrollY']>;
+    abstract readonly scrollX: ConfigHookType<IhoTableConfig['scrollX']>;
+    abstract readonly editRules: ConfigHookType<IhoTableConfig['editRules']>;
 }
 export interface FieldHookContext {
     index: number;
@@ -55,69 +60,88 @@ export declare abstract class AbstractFieldHooks {
     abstract readonly fieldList: SyncWaterfallHook<WithTableConfig<[IhoTableFieldItem[]]>>;
     abstract readonly fieldEnd: AsyncParallelHook<WithTableConfig>;
 }
-export declare type WithIhoEventContext<T> = T extends any[] ? [...T, IhoTableConfig, Nullable<VxeTableInstance>] : [T, IhoTableConfig, Nullable<VxeTableInstance>];
+export declare type WithIhoEventContext<T> = T extends any[] ? [...T, IhoTableHandler & {
+    $table: Nullable<VxeTableInstance>;
+}, IhoTableConfig] : [T, IhoTableHandler & {
+    $table: Nullable<VxeTableInstance>;
+}, IhoTableConfig];
+declare type EventHookType<T extends Func> = AsyncParallelHook<WithIhoEventContext<Parameters<T>>>;
 declare type VxeEventTypes = Required<{
-    readonly [K in keyof VxeTableEventProps]: AsyncParallelHook<WithIhoEventContext<VxeTableEventProps[K]>>;
+    readonly [K in keyof VxeTableEventProps]: EventHookType<NotNull<VxeTableEventProps[K]>>;
 }>;
 export declare abstract class AbstractEventHooks implements VxeEventTypes {
-    abstract readonly onKeydownStart: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.KeydownStart>>;
-    abstract readonly onKeydown: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.Keydown>>;
-    abstract readonly onKeydownEnd: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.KeydownEnd>>;
-    abstract readonly onPaste: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.Paste>>;
-    abstract readonly onCopy: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.Copy>>;
-    abstract readonly onCut: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.Cut>>;
-    abstract readonly onCurrentChange: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.CurrentChange>>;
-    abstract readonly onRadioChange: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.RadioChange>>;
-    abstract readonly onCheckboxChange: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.CheckboxChange>>;
-    abstract readonly onCheckboxAll: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.CheckboxAll>>;
-    abstract readonly onCheckboxRangeStart: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.CheckboxRangeStart>>;
-    abstract readonly onCheckboxRangeChange: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.CheckboxRangeChange>>;
-    abstract readonly onCheckboxRangeEnd: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.CheckboxRangeEnd>>;
-    abstract readonly onCellClick: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.CellClick>>;
-    abstract readonly onCellDblclick: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.CellDblclick>>;
-    abstract readonly onCellMenu: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.CellMenu>>;
-    abstract readonly onCellMouseenter: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.CellMouseenter>>;
-    abstract readonly onCellMouseleave: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.CellMouseleave>>;
-    abstract readonly onHeaderCellClick: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.HeaderCellClick>>;
-    abstract readonly onHeaderCellDblclick: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.HeaderCellDblclick>>;
-    abstract readonly onHeaderCellMenu: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.HeaderCellMenu>>;
-    abstract readonly onFooterCellClick: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.FooterCellClick>>;
-    abstract readonly onFooterCellDblclick: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.FooterCellDblclick>>;
-    abstract readonly onFooterCellMenu: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.FooterCellMenu>>;
-    abstract readonly onSortChange: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.SortChange>>;
-    abstract readonly onFilterChange: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.FilterChange>>;
-    abstract readonly onFilterVisible: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.FilterVisible>>;
-    abstract readonly onResizableChange: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.ResizableChange>>;
-    abstract readonly onToggleRowExpand: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.ToggleRowExpand>>;
-    abstract readonly onToggleTreeExpand: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.ToggleTreeExpand>>;
-    abstract readonly onMenuClick: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.MenuClick>>;
-    abstract readonly onEditClosed: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.EditClosed>>;
-    abstract readonly onEditActived: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.EditActived>>;
-    abstract readonly onEditDisabled: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.EditDisabled>>;
-    abstract readonly onValidError: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.ValidError>>;
-    abstract readonly onScroll: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.Scroll>>;
-    abstract readonly onCustom: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.Custom>>;
-    abstract readonly onOpenFnr: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.OpenFnr>>;
-    abstract readonly onFnrChange: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.FnrChange>>;
-    abstract readonly onFnrFind: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.FnrFind>>;
-    abstract readonly onFnrFindAll: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.FnrFindAll>>;
-    abstract readonly onFnrReplace: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.FnrReplace>>;
-    abstract readonly onFnrReplaceAll: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.FnrReplaceAll>>;
-    abstract readonly onCellAreaCopy: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.CellAreaCopy>>;
-    abstract readonly onCellAreaCut: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.CellAreaCut>>;
-    abstract readonly onCellAreaPaste: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.CellAreaPaste>>;
-    abstract readonly onCellAreaMerge: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.CellAreaMerge>>;
-    abstract readonly onClearCellAreaMerge: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.ClearCellAreaMerge>>;
-    abstract readonly onHeaderCellAreaSelection: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.HeaderCellAreaSelection>>;
-    abstract readonly onCellAreaSelectionStart: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.CellAreaSelectionStart>>;
-    abstract readonly onCellAreaSelectionDrag: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.CellAreaSelectionDrag>>;
-    abstract readonly onCellAreaSelectionEnd: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.CellAreaSelectionEnd>>;
-    abstract readonly onCellAreaExtensionStart: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.CellAreaExtensionStart>>;
-    abstract readonly onCellAreaExtensionDrag: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.CellAreaExtensionDrag>>;
-    abstract readonly onCellAreaExtensionEnd: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.CellAreaExtensionEnd>>;
-    abstract readonly onCellAreaArrowsStart: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.CellAreaArrowsStart>>;
-    abstract readonly onCellAreaArrowsEnd: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.CellAreaArrowsEnd>>;
-    abstract readonly onActiveCellChangeStart: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.ActiveCellChangeStart>>;
-    abstract readonly onActiveCellChangeEnd: AsyncParallelHook<WithIhoEventContext<VxeTableEvents.ActiveCellChangeEnd>>;
+    abstract readonly onKeydownStart: EventHookType<VxeTableEvents.KeydownStart>;
+    abstract readonly onKeydown: EventHookType<VxeTableEvents.Keydown>;
+    abstract readonly onKeydownEnd: EventHookType<VxeTableEvents.KeydownEnd>;
+    abstract readonly onPaste: EventHookType<VxeTableEvents.Paste>;
+    abstract readonly onCopy: EventHookType<VxeTableEvents.Copy>;
+    abstract readonly onCut: EventHookType<VxeTableEvents.Cut>;
+    abstract readonly onCurrentChange: EventHookType<VxeTableEvents.CurrentChange>;
+    abstract readonly onRadioChange: EventHookType<VxeTableEvents.RadioChange>;
+    abstract readonly onCheckboxChange: EventHookType<VxeTableEvents.CheckboxChange>;
+    abstract readonly onCheckboxAll: EventHookType<VxeTableEvents.CheckboxAll>;
+    abstract readonly onCheckboxRangeStart: EventHookType<VxeTableEvents.CheckboxRangeStart>;
+    abstract readonly onCheckboxRangeChange: EventHookType<VxeTableEvents.CheckboxRangeChange>;
+    abstract readonly onCheckboxRangeEnd: EventHookType<VxeTableEvents.CheckboxRangeEnd>;
+    abstract readonly onCellClick: EventHookType<VxeTableEvents.CellClick>;
+    abstract readonly onCellDblclick: EventHookType<VxeTableEvents.CellDblclick>;
+    abstract readonly onCellMenu: EventHookType<VxeTableEvents.CellMenu>;
+    abstract readonly onCellMouseenter: EventHookType<VxeTableEvents.CellMouseenter>;
+    abstract readonly onCellMouseleave: EventHookType<VxeTableEvents.CellMouseleave>;
+    abstract readonly onHeaderCellClick: EventHookType<VxeTableEvents.HeaderCellClick>;
+    abstract readonly onHeaderCellDblclick: EventHookType<VxeTableEvents.HeaderCellDblclick>;
+    abstract readonly onHeaderCellMenu: EventHookType<VxeTableEvents.HeaderCellMenu>;
+    abstract readonly onFooterCellClick: EventHookType<VxeTableEvents.FooterCellClick>;
+    abstract readonly onFooterCellDblclick: EventHookType<VxeTableEvents.FooterCellDblclick>;
+    abstract readonly onFooterCellMenu: EventHookType<VxeTableEvents.FooterCellMenu>;
+    abstract readonly onSortChange: EventHookType<VxeTableEvents.SortChange>;
+    abstract readonly onFilterChange: EventHookType<VxeTableEvents.FilterChange>;
+    abstract readonly onFilterVisible: EventHookType<VxeTableEvents.FilterVisible>;
+    abstract readonly onResizableChange: EventHookType<VxeTableEvents.ResizableChange>;
+    abstract readonly onToggleRowExpand: EventHookType<VxeTableEvents.ToggleRowExpand>;
+    abstract readonly onToggleTreeExpand: EventHookType<VxeTableEvents.ToggleTreeExpand>;
+    abstract readonly onMenuClick: EventHookType<VxeTableEvents.MenuClick>;
+    abstract readonly onEditClosed: EventHookType<VxeTableEvents.EditClosed>;
+    abstract readonly onEditActived: EventHookType<VxeTableEvents.EditActived>;
+    abstract readonly onEditDisabled: EventHookType<VxeTableEvents.EditDisabled>;
+    abstract readonly onValidError: EventHookType<VxeTableEvents.ValidError>;
+    abstract readonly onScroll: EventHookType<VxeTableEvents.Scroll>;
+    abstract readonly onCustom: EventHookType<VxeTableEvents.Custom>;
+    abstract readonly onOpenFnr: EventHookType<VxeTableEvents.OpenFnr>;
+    abstract readonly onFnrChange: EventHookType<VxeTableEvents.FnrChange>;
+    abstract readonly onFnrFind: EventHookType<VxeTableEvents.FnrFind>;
+    abstract readonly onFnrFindAll: EventHookType<VxeTableEvents.FnrFindAll>;
+    abstract readonly onFnrReplace: EventHookType<VxeTableEvents.FnrReplace>;
+    abstract readonly onFnrReplaceAll: EventHookType<VxeTableEvents.FnrReplaceAll>;
+    abstract readonly onCellAreaCopy: EventHookType<VxeTableEvents.CellAreaCopy>;
+    abstract readonly onCellAreaCut: EventHookType<VxeTableEvents.CellAreaCut>;
+    abstract readonly onCellAreaPaste: EventHookType<VxeTableEvents.CellAreaPaste>;
+    abstract readonly onCellAreaMerge: EventHookType<VxeTableEvents.CellAreaMerge>;
+    abstract readonly onClearCellAreaMerge: EventHookType<VxeTableEvents.ClearCellAreaMerge>;
+    abstract readonly onHeaderCellAreaSelection: EventHookType<VxeTableEvents.HeaderCellAreaSelection>;
+    abstract readonly onCellAreaSelectionStart: EventHookType<VxeTableEvents.CellAreaSelectionStart>;
+    abstract readonly onCellAreaSelectionDrag: EventHookType<VxeTableEvents.CellAreaSelectionDrag>;
+    abstract readonly onCellAreaSelectionEnd: EventHookType<VxeTableEvents.CellAreaSelectionEnd>;
+    abstract readonly onCellAreaExtensionStart: EventHookType<VxeTableEvents.CellAreaExtensionStart>;
+    abstract readonly onCellAreaExtensionDrag: EventHookType<VxeTableEvents.CellAreaExtensionDrag>;
+    abstract readonly onCellAreaExtensionEnd: EventHookType<VxeTableEvents.CellAreaExtensionEnd>;
+    abstract readonly onCellAreaArrowsStart: EventHookType<VxeTableEvents.CellAreaArrowsStart>;
+    abstract readonly onCellAreaArrowsEnd: EventHookType<VxeTableEvents.CellAreaArrowsEnd>;
+    abstract readonly onActiveCellChangeStart: EventHookType<VxeTableEvents.ActiveCellChangeStart>;
+    abstract readonly onActiveCellChangeEnd: EventHookType<VxeTableEvents.ActiveCellChangeEnd>;
+}
+declare type DataHookContext = {
+    remove(): void;
+    $table: MaybeRef<Nullable<VxeTableInstance>>;
+    index: number;
+    insertBefore(data: ArrayAble<AnyObject>): void;
+    insertAfter(data: ArrayAble<AnyObject>): void;
+};
+export declare type WithTableDataContext<T> = T extends any[] ? [...T, ...WithTableConfig<DataHookContext>] : [T, ...WithTableConfig<DataHookContext>];
+export declare abstract class AbstractDataHooks {
+    abstract readonly data: AsyncSeriesHook<WithTableDataContext<[AnyObject]>>;
+}
+export declare abstract class AbstractSetupHooks {
+    abstract readonly setup: SyncHook<[Ref<IhoTableConfig>, Ref<IhoTableFieldItem[]>]>;
 }
 export {};

package/es/components/iho-table/src/types/pluginType.js

@@ -1 +1 @@
-export { AbstractConfigHooks, AbstractEventHooks, AbstractFieldHooks } from './pluginType2.js';
+export { AbstractConfigHooks, AbstractDataHooks, AbstractEventHooks, AbstractFieldHooks, AbstractSetupHooks } from './pluginType2.js';

package/es/components/iho-table/src/types/pluginType2.js

@@ -4,5 +4,9 @@ class AbstractFieldHooks {
 }
 class AbstractEventHooks {
 }
+class AbstractDataHooks {
+}
+class AbstractSetupHooks {
+}
 
-export { AbstractConfigHooks, AbstractEventHooks, AbstractFieldHooks };
+export { AbstractConfigHooks, AbstractDataHooks, AbstractEventHooks, AbstractFieldHooks, AbstractSetupHooks };

package/es/components/iho-table/src/utils/index2.js

@@ -11,7 +11,7 @@ function getRowHeight() {
   var _a, _b, _c;
   const config = inject(InjectionIhoTableConfig);
   if (!config) {
-    IhoTableWarn("please use this function(getRowHeight) in setup environment");
+    IhoTableWarn("this function(getRowHeight) only can be used in setup environment");
   }
   return (_c = (_b = (_a = config == null ? void 0 : config.value) == null ? void 0 : _a.rowConfig) == null ? void 0 : _b.height) != null ? _c : 32;
 }