rw-admin-ui 1.0.0

package/packages/basic-table/src/basic-table-column.vue

@@ -0,0 +1,264 @@
+<script>
+/* eslint-disable no-console */
+/**
+ * 组件：ElBasicTableColumn
+ * 职责：将业务列配置映射为 ElementUI 的 `el-table-column` 并提供插槽渲染与默认溢出处理
+ * 说明：不使用函数式组件 以保证 inject 与组件树的兼容性
+ */
+// 列渲染子组件：封装 el-table-column 属性映射与默认溢出处理（Hover 展示完整文本）
+// 注意：不能使用函数式组件 否则在 npm 包环境中 inject 和组件树查找可能失效
+import ElTableColumn from 'rowinself-ui/packages/table-column';
+import OverflowCell from './overflow-cell.js';
+import { getByPath } from './utils';
+
+export default {
+  name: 'ElBasicTableColumn',
+  components: { ElTableColumn, OverflowCell },
+  inject: {
+    /**
+     * 从 ElBasicTable 注入获取插槽的函数 用于获取最新的 `$scopedSlots`。
+     * 使用函数可避免直接引用导致的响应性问题
+     * @returns {() => Object} 返回一个函数 执行后得到插槽对象
+     */
+    getBasicTableSlots: { default: () => () => ({}) }
+  },
+  props: {
+    /**
+     * 列配置对象（来自父组件 normalizedColumns）
+     * @type {Object}
+     */
+    column: { type: Object, required: true },
+    /** 全局溢出省略开关（列级未设置时生效） */
+    ellipsis: { type: Boolean, default: false }
+  },
+  computed: {
+    /**
+     * 列类型
+     * @returns {string}
+     */
+    colType() {
+      return this.column.type || 'default';
+    },
+    /**
+     * 列标题
+     * @returns {string}
+     */
+    colLabel() {
+      return this.column.title || this.column.label || '';
+    },
+    /**
+     * 列字段（dataIndex/prop/key/field）
+     * @returns {string}
+     */
+    colProp() {
+      return this.column.dataIndex || this.column.prop || this.column.key || this.column.field || '';
+    },
+    /**
+     * 插槽名（具名单元格插槽）
+     * @returns {string|null}
+     */
+    slotName() {
+      return this.column.slot || null;
+    },
+    /**
+     * 是否显示溢出提示（列级优先 其次使用全局 ellipsis）
+     * @returns {boolean}
+     */
+    showOverflowTooltip() {
+      const raw = this.column.showOverflowTooltip;
+      return raw != null ? raw : !!this.ellipsis;
+    },
+    /**
+     * 是否使用自定义 Popover 溢出处理（默认列、无插槽、开启溢出提示且存在字段）
+     * @returns {boolean}
+     */
+    usePopoverOverflow() {
+      return this.colType === 'default' && !this.slotName && !!this.showOverflowTooltip && !!this.colProp;
+    },
+    /**
+     * 透传给 el-table-column 的属性集合
+     * @returns {Object}
+     */
+    tableColumnProps() {
+      return {
+        type: this.colType,
+        label: this.colLabel,
+        prop: this.colProp,
+        width: this.column.width,
+        minWidth: this.column.minWidth,
+        align: this.column.align,
+        headerAlign: this.column.headerAlign,
+        fixed: this.column.fixed,
+        sortable: this.column.sortable || false,
+        index: this.column.index,
+        showOverflowTooltip: this.usePopoverOverflow ? false : this.showOverflowTooltip
+      };
+    },
+    /**
+     * 是否存在对应的具名插槽（例如：statusCell、roleCell 等）
+     * @returns {boolean}
+     */
+    hasNamedSlot() {
+      if (!this.slotName) return false;
+      const slots = this.getBasicTableSlots();
+      return slots && typeof slots[this.slotName] === 'function';
+    },
+    /** 是否为手动模拟的索引列 */
+    isIndexColumn() {
+      return this.column.key === '__index__';
+    }
+  },
+  methods: {
+    /**
+     * 构造传入插槽的列对象 补充 `field` 别名 兼容示例 `column.field` 写法
+     * @returns {Object}
+     */
+    buildSlotColumn() {
+      // 优先使用 dataIndex/prop
+      let field = this.colProp || (this.column && this.column.field) || '';
+      // 若未提供字段 且存在具名插槽 则尝试根据插槽名推导：去掉尾部 "Cell/cell"
+      if (!field && this.slotName) {
+        const name = String(this.slotName);
+        field = name.replace(/(Cell|cell)$/g, '');
+      }
+      return { ...(this.column || {}), field };
+    },
+    /**
+     * 渲染具名插槽内容
+     * @param {Object} scope ElementUI 提供的作用域对象
+     * @returns {VNode|null}
+     */
+    renderNamedSlot(scope) {
+      if (!this.slotName) return null; // 未声明具名插槽时直接返回
+      const slots = this.getBasicTableSlots();
+      const fn = slots && slots[this.slotName];
+      if (!fn) return null; // 未找到对应插槽函数
+      try {
+        // 传入 record/row 以及补充的 column.field
+        return fn({
+          row: scope.row,
+          record: scope.row,
+          column: this.buildSlotColumn(),
+          $index: scope.$index
+        });
+      } catch (err) {
+        // 插槽渲染异常仅记录日志 不中断表格渲染
+        console.error('[ElBasicTableColumn] renderNamedSlot error:', err);
+        return null;
+      }
+    },
+    /**
+     * 渲染通用 bodyCell 插槽
+     * @param {Object} scope ElementUI 提供的作用域对象
+     * @returns {VNode|null}
+     */
+    renderBodySlot(scope) {
+      const slots = this.getBasicTableSlots();
+      const fn = slots && slots.bodyCell;
+      if (typeof fn !== 'function') return null; // 未提供 bodyCell 插槽
+      try {
+        return fn({
+          row: scope.row,
+          record: scope.row,
+          column: this.buildSlotColumn(),
+          $index: scope.$index
+        });
+      } catch (err) {
+        console.error('[ElBasicTableColumn] renderBodySlot error:', err);
+        return null;
+      }
+    },
+    // 判断插槽输出是否为空内容（null/undefined/[]/仅注释或空文本）
+    isEmptyRender(vnode) {
+      if (vnode == null) return true;
+      if (Array.isArray(vnode)) {
+        if (!vnode.length) return true;
+        return vnode.every((n) => {
+          if (!n) return true;
+          // Vue2 注释节点：isComment === true；空文本：text === '' 且无 tag
+          return (n.isComment === true) || (n.text != null && String(n.text).trim() === '' && !n.tag);
+        });
+      }
+      return (vnode.isComment === true) || (vnode.text != null && String(vnode.text).trim() === '' && !vnode.tag);
+    },
+    // 默认文本渲染（作为 bodyCell 为空时的回退）
+    renderPlainTextCell(scope) {
+      const value = scope && scope.row ? getByPath(scope.row, this.colProp) : '';
+      const text = value == null ? '' : String(value);
+      return this.$createElement('span', text);
+    },
+    /**
+     * 渲染溢出单元格，使用 Popover 展示完整文本
+     * @param {Object} scope ElementUI 提供的作用域对象
+     * @returns {VNode}
+     */
+    renderOverflowCell(scope) {
+      const value = scope && scope.row ? getByPath(scope.row, this.colProp) : '';
+      const text = value == null ? '' : String(value);
+      return this.$createElement(OverflowCell, { props: { text } });
+    }
+  },
+  render (h) {
+    console.log("::: ",)
+    // 分组列：存在 children 时递归渲染子列 并以一个分组列包裹
+    const hasChildren = Array.isArray(this.column && this.column.children) && this.column.children.length > 0;
+    if (hasChildren) {
+      // 递归渲染子列组件 保持 ellipsis 透传
+      const childNodes = this.column.children.map((child) =>
+        h('ElBasicTableColumn', { props: { column: child, ellipsis: this.ellipsis } })
+      );
+      // 分组列基本属性（不传递子列专属属性）
+      const groupProps = {
+        type: 'default',
+        label: this.colLabel,
+        align: this.column.align,
+        headerAlign: this.column.headerAlign,
+        fixed: this.column.fixed
+      };
+      return h(ElTableColumn, { props: groupProps }, childNodes);
+    }
+
+    const scopedSlots = {};
+    // 非默认列类型（如 selection/index）不自定义单元格渲染 交由 Element 原生处理
+    const validTypes = ['selection', 'index', 'expand'];
+    // console.log("::: ",this.colType,validTypes.includes(this.colType))
+    if (validTypes.includes(this.colType)) {
+    // if (this.colType !== 'default') {
+      return h(ElTableColumn, { props: this.tableColumnProps, scopedSlots });
+    }
+    // 优先使用具名插槽 与示例保持一致
+    if (this.slotName && this.hasNamedSlot) {
+      scopedSlots.default = (scope) => this.renderNamedSlot(scope);
+    } else if (this.isIndexColumn) {
+      // 索引列手动渲染
+      scopedSlots.default = (scope) => {
+        const { index } = this.column;
+        let val = scope.$index + 1;
+        if (typeof index === 'function') {
+          val = index(scope.$index);
+        }
+        return this.$createElement('span', val);
+      };
+    } else {
+      // 未提供具名插槽时 尝试使用通用 bodyCell 插槽 否则回退到溢出渲染
+      const slots = this.getBasicTableSlots();
+      const hasBodyCell = slots && typeof slots.bodyCell === 'function';
+      if (hasBodyCell) {
+        scopedSlots.default = (scope) => {
+          const vnode = this.renderBodySlot(scope);
+          if (this.isEmptyRender(vnode)) {
+            return this.usePopoverOverflow ? this.renderOverflowCell(scope) : this.renderPlainTextCell(scope);
+          }
+          return vnode;
+        };
+      } else if (this.usePopoverOverflow) {
+        scopedSlots.default = (scope) => this.renderOverflowCell(scope);
+      } else {
+        scopedSlots.default = (scope) => this.renderPlainTextCell(scope);
+      }
+    }
+    // 返回最终的 table-column VNode 透传属性与 scopedSlots
+    return h(ElTableColumn, { props: this.tableColumnProps, scopedSlots });
+  }
+};
+</script>

package/packages/basic-table/src/basic-table.vue

@@ -0,0 +1,336 @@
+<template>
+  <div class="el-basic-table">
+    <div v-if="useSearchForm" class="el-basic-table__form">
+      <el-basic-form
+        v-bind="formConfig || {}"
+        :table-action="tableActionContext"
+        @submit="onFormSubmit"
+        @register="onFormRegister"
+      />
+    </div>
+    <!-- v-if="title || titleHelpMessage" -->
+    <div class="el-basic-table__header">
+      <div class="el-basic-table__title">{{ title }}</div>
+      <div v-if="titleHelpMessage" class="el-basic-table__help">{{ titleHelpMessage }}</div>
+      <div class="el-basic-table__toolbar">
+        <slot name="toolbar"></slot>
+      </div>
+    </div>
+    <el-table
+      ref="tableRef"
+      v-loading="internalLoading"
+      :data="internalData"
+      :stripe="striped"
+      :border="bordered"
+      :max-height="maxHeight"
+      :size="size"
+      :row-key="rowKey"
+      :tree-props="treeProps"
+      :highlight-current-row="highlightCurrentRow"
+      :empty-text="emptyText"
+      :show-summary="showSummary"
+      :summary-method="summaryMethod"
+      :span-method="handleSpanMethod"
+      @selection-change="onSelectionChange"
+      @row-click="onRowClick"
+    >
+      <el-basic-table-column
+        v-for="(col, idx) in normalizedColumns"
+        :key="col.key || col.prop || idx"
+        :column="col"
+        :ellipsis="ellipsis"
+      />
+      <!-- <template v-if="$slots.append" slot="append">
+        <slot name="append"></slot>
+      </template>
+      <template v-if="$slots.empty" slot="empty">
+        <slot name="empty"></slot>
+      </template> -->
+    </el-table>
+    <div v-if="showPagination" class="el-basic-table__pagination">
+      <el-pagination
+        v-bind="internalPagination"
+        @current-change="handlePageChange"
+        @size-change="handlePageSizeChange"
+      />
+    </div>
+  </div>
+</template>
+<script>
+// 依赖组件：基础表格、分页、搜索表单与列渲染子组件
+// 文件职能：封装基础表格行为（列配置、分页、远程加载、选择行、搜索联动），暴露完整方法集供外部按需控制
+// 说明：该文件聚合 UI 与对外 API，核心行为拆分到 mixins 保持清晰职责
+import ElTable from 'rowinself-ui/packages/table';
+import ElPagination from 'rowinself-ui/packages/pagination';
+import ElBasicForm from 'rowinself-ui/packages/basic-form';
+import ElBasicTableColumn from './basic-table-column.vue';
+import actions from './actions';
+import { mapColumns } from './utils';
+import fetchMixin from './mixins/fetch';
+import paginationMixin from './mixins/pagination';
+import formMixin from './mixins/form';
+import actionsContextMixin from './mixins/actions-context';
+import watchersMixin from './mixins/watchers';
+
+export default {
+  name: 'ElBasicTable',
+  components: { ElTable, ElPagination, ElBasicForm, ElBasicTableColumn },
+  mixins: [fetchMixin, paginationMixin, formMixin, actionsContextMixin, watchersMixin],
+  provide() {
+    return {
+      // 提供一个函数来获取最新的 $scopedSlots，保证响应性
+      getBasicTableSlots: () => this.$scopedSlots
+    };
+  },
+  props: {
+    // 标题与提示
+    /**
+     * 表格标题
+     * @type {String}
+     */
+    title: String,
+    /**
+     * 标题右侧提示文案
+     * @type {String}
+     */
+    titleHelpMessage: String,
+    // 列配置与数据
+    /**
+     * 列配置数组，映射到每个列的属性
+     * @type {Array<Object>}
+     */
+    columns: { type: Array, default: () => [] },
+    /**
+     * 本地数据源（与 api 互斥时以 api 为准）
+     * @type {Array<Object>}
+     */
+    dataSource: { type: Array, default: () => [] },
+    // 远程加载
+    /**
+     * 远程数据请求函数 (params) => Promise<{items,total}> | Array
+     * @type {Function}
+     */
+    api: Function,
+    // 外观与行为
+    /** 是否显示斑马纹 */
+    striped: Boolean,
+    /** 是否显示边框 */
+    bordered: Boolean,
+    /** 表格尺寸 (medium/small/mini) */
+    size: String,
+    /** 行主键，可为字段名或函数 */
+    rowKey: [String, Function],
+    /** 空数据文案 */
+    emptyText: String,
+    /** 高亮当前行 */
+    highlightCurrentRow: Boolean,
+    /** 是否显示合计 */
+    showSummary: Boolean,
+    /** 合计计算方法 */
+    summaryMethod: Function,
+    /** 合并单元格方法 */
+    spanMethod: Function,
+    /** 分页配置对象，或 false 不显示 */
+    pagination: Object,
+    /** 表格 loading 状态 */
+    loading: Boolean,
+    /** 文本溢出省略（全局） */
+    ellipsis: { type: Boolean, default: true },
+    /** 自动为数据补充 key */
+    autoCreateKey: { type: Boolean, default: true },
+    /** 点击行是否切换勾选 */
+    clickToRowSelect: { type: Boolean, default: false },
+    /** 翻页是否清空勾选 */
+    clearSelectOnPageChange: { type: Boolean, default: false },
+    // 搜索表单
+    /** 是否启用搜索表单 */
+    useSearchForm: { type: Boolean, default: false },
+    /** 搜索表单配置（透传给 ElBasicForm） */
+    formConfig: Object,
+    // 树形表格
+    /** 树形表格子项字段名与是否有子项标志 */
+    treeProps: {
+      type: Object,
+      default: () => ({
+        /** 子项字段名 */
+        children: 'children',
+        /** 是否有子项标志 */
+        hasChildren: 'hasChildren'
+      })
+    },
+    // 请求钩子与映射
+    /** 请求前对参数处理 */
+    beforeFetch: Function,
+    /** 请求后对返回值处理 */
+    afterFetch: Function,
+    /** 搜索条件处理钩子 */
+    handleSearchInfoFn: Function,
+    /** 字段映射：pageField/sizeField/listField/totalField */
+    fetchSetting: {
+      type: Object,
+      default: () => ({
+        /** 列表字段名 */
+        listField: 'list',
+        /** 总数字段名（支持点号路径如 page.totalRowNum） */
+        totalField: 'page.totalRowNum',
+        /** 当前页码字段名 */
+        pageField: 'page.perPage',
+        /** 每页条数字段名 */
+        sizeField: 'page.pageNum'
+      })
+    },
+    /** 是否在挂载后立即请求 */
+    immediate: { type: Boolean, default: true },
+    /** 外部传入的搜索条件（受控） */
+    searchInfo: Object,
+    // 特殊列控制
+    /** 是否显示索引列 */
+    showIndexColumn: { type: Boolean, default: true },
+    /** 索引列标题 */
+    indexColumnTitle: { type: String, default: '序号' },
+    /** 索引列属性（宽度/对齐/index 回调） */
+    indexColumnProps: { type: Object, default: () => ({}) },
+    // 尺寸与滚动
+    /** 最大高度，超出滚动 */
+    maxHeight: Number,
+    /** 选择列配置（true/对象） */
+    rowSelection: [Boolean, Object]
+  },
+  data() {
+    return {
+      // 内部数据状态
+      /** 当前渲染的数据源（应用了 ensureKeys） */
+      internalData: this.dataSource || [],
+      /** 当前 loading 状态 */
+      internalLoading: !!this.loading,
+      /** 当前列配置（内部副本） */
+      internalColumns: this.columns || [],
+      /** 当前分页配置（内部副本） */
+      internalPagination: this.normalizePagination(this.pagination),
+      /** 最后一次请求错误 */
+      lastFetchError: null,
+      /** 当前选中的行（表格事件同步） */
+      selectedRows: [],
+      /** 当前选中行的主键集合 */
+      selectedRowKeys: [],
+      /** 原始接口返回对象（最近一次） */
+      rawResult: null,
+      /** 是否显示分页（受控） */
+      showPaginationFlag: this.pagination !== false,
+      /** 表单动作对象（@register 注入） */
+      formActions: null,
+      /** 内部搜索条件，避免直接修改 prop */
+      internalSearchInfo: this.searchInfo || {}
+    };
+  },
+  computed: {
+    /**
+     * 组装最终用于渲染的列配置（前置特殊列 + 常规列）
+     * @returns {Array<Object>} 渲染列数组
+     */
+    normalizedColumns() {
+      // console.log('BasicTable indexColumnProps:', this.indexColumnProps);
+      return mapColumns({
+        columns: this.internalColumns,
+        ellipsis: this.ellipsis,
+        showIndexColumn: this.showIndexColumn,
+        indexColumnTitle: this.indexColumnTitle,
+        indexColumnProps: this.indexColumnProps,
+        rowSelection: this.rowSelection
+      });
+    }
+    // showPagination/tableActionContext 已拆分至 mixins，保持本组件只关注数据与渲染
+  },
+
+  mounted() {
+    this.$emit('register', this.tableActionContext);
+    if (this.immediate && typeof this.api === 'function') this.reload();
+  },
+
+  methods: {
+    ...actions,
+    /**
+     * 处理单元格合并
+     */
+    handleSpanMethod({ row, column, rowIndex, columnIndex }) {
+      // 获取当前列的配置信息
+      const prop = column.property;
+      const colConfig = prop ? this.normalizedColumns.find(c => c.prop === prop || c.field === prop) : null;
+
+      // 补充 column.field 字段，兼容用户在 spanMethod 中使用 column.field
+      if (colConfig && colConfig.field && !column.field) {
+        column.field = colConfig.field;
+      }
+
+      // 优先使用传入的 spanMethod
+      if (typeof this.spanMethod === 'function') {
+        return this.spanMethod({ row, column, rowIndex, columnIndex });
+      }
+      
+      // 自动合并逻辑：检查列配置是否有 autoSpan
+      if (colConfig && colConfig.autoSpan) {
+          const data = this.internalData;
+          // 使用 getByPath 获取值，以支持嵌套字段
+          const getValue = (r, p) => {
+            if (!r || !p) return undefined;
+            // 简单属性直接获取，避免 getByPath 性能开销（如果 prop 不含点号）
+            if (p.indexOf('.') === -1) return r[p];
+            // 简单实现 getByPath，避免引入 utils 依赖（或者假设 prop 即为 key）
+            // 这里我们假设 data 中 key 与 prop 一致，或者使用 row[prop]
+            // Element UI 的 row[column.property] 通常能取到值
+            return r[p];
+          };
+
+          const currentValue = row[prop];
+          const prevRow = data[rowIndex - 1];
+
+          // 如果上一行值相同，则合并（当前隐藏）
+          if (prevRow && prevRow[prop] === currentValue) {
+            return { rowspan: 0, colspan: 0 };
+          }
+
+          // 否则计算向下合并行数
+          let rowspan = 1;
+          for (let i = rowIndex + 1; i < data.length; i++) {
+            if (data[i][prop] === currentValue) {
+              rowspan++;
+            } else {
+              break;
+            }
+          }
+          return { rowspan, colspan: 1 };
+        }
+    },
+    /**
+     * 运行时设置表格属性（列/数据/loading/分页/选中/索引列/标题/搜索条件等）
+     * @param {Object} nextProps 需更新的属性集合
+     */
+    setProps(nextProps) {
+      const propsToUpdate = nextProps || {};
+      if ('columns' in propsToUpdate) this.internalColumns = Array.isArray(propsToUpdate.columns) ? propsToUpdate.columns : [];
+      if ('dataSource' in propsToUpdate) this.internalData = Array.isArray(propsToUpdate.dataSource) ? propsToUpdate.dataSource : [];
+      if ('loading' in propsToUpdate) this.internalLoading = !!propsToUpdate.loading;
+      if ('pagination' in propsToUpdate) this.internalPagination = this.normalizePagination(propsToUpdate.pagination);
+      if ('rowSelection' in propsToUpdate) this.$emit('update:rowSelection', propsToUpdate.rowSelection);
+      if ('showIndexColumn' in propsToUpdate) this.$emit('update:showIndexColumn', !!propsToUpdate.showIndexColumn);
+      if ('searchInfo' in propsToUpdate) { this.internalSearchInfo = propsToUpdate.searchInfo || {}; this.$emit('update:searchInfo', propsToUpdate.searchInfo); }
+      if ('title' in propsToUpdate) this.$emit('update:title', propsToUpdate.title);
+      if ('indexColumnProps' in propsToUpdate) this.$emit('update:indexColumnProps', propsToUpdate.indexColumnProps);
+      if ('indexColumnTitle' in propsToUpdate) this.$emit('update:indexColumnTitle', propsToUpdate.indexColumnTitle);
+    },
+    setLoading(loading) { this.internalLoading = !!loading; },
+    setColumns(nextColumns) { this.internalColumns = Array.isArray(nextColumns) ? nextColumns : []; },
+    setDataSource(nextDataSource) { this.internalData = Array.isArray(nextDataSource) ? this.ensureKeys(nextDataSource) : []; },
+    /** 获取当前数据源副本 */
+    getDataSource() { return this.internalData.slice(); },
+    /** 获取原始接口返回 */
+    getRawDataSource() { return this.rawResult; },
+    /** 获取当前列配置副本 */
+    getColumns() { return (this.internalColumns || []).slice(); },
+    /** 设置数据源（别名） */
+    setTableData(values) { this.setDataSource(values); },
+    /** 合并设置分页信息 */
+    setPagination(info) { this.internalPagination = { ...this.internalPagination, ...(info || {}) }; }
+  }
+};
+</script>

package/packages/basic-table/src/mixins/actions-context.js

@@ -0,0 +1,47 @@
+/**
+ * 动作上下文混入（Actions Context Mixin）
+ * 职责：
+ * - 生成对外暴露的方法集合，供父级通过 @register 获取以进行外部控制
+ * 设计：
+ * - 仅聚合现有方法，不承担业务逻辑
+ */
+export default {
+  computed: {
+    /**
+     * 对外动作上下文对象
+     * @returns {Object} 方法集合
+     */
+    tableActionContext() {
+      return {
+        setProps: this.setProps,
+        setLoading: this.setLoading,
+        reload: this.reload,
+        getDataSource: this.getDataSource,
+        clearSelection: this.clearSelection,
+        setColumns: this.setColumns,
+        setDataSource: this.setDataSource,
+        getRawDataSource: this.getRawDataSource,
+        getColumns: this.getColumns,
+        setTableData: this.setTableData,
+        setPagination: this.setPagination,
+        deleteSelectRowByKey: this.deleteSelectRowByKey,
+        getSelectRowKeys: this.getSelectRowKeys,
+        getSelectRows: this.getSelectRows,
+        clearSelectedRowKeys: this.clearSelectedRowKeys,
+        setSelectedRowKeys: this.setSelectedRowKeys,
+        getPaginationRef: this.getPaginationRef,
+        getShowPagination: this.getShowPagination,
+        setShowPagination: this.setShowPagination,
+        getRowSelection: this.getRowSelection,
+        updateTableData: this.updateTableData,
+        updateTableDataRecord: this.updateTableDataRecord,
+        deleteTableDataRecord: this.deleteTableDataRecord,
+        insertTableDataRecord: this.insertTableDataRecord,
+        getForm: this.getForm,
+        expandAll: this.expandAll,
+        collapseAll: this.collapseAll,
+        redoHeight: this.redoHeight
+      };
+    }
+  }
+};