@gct-paas/v-ben 0.1.4-dev.10 → 0.1.4-dev.12

package/es/components/v-ben-dropdown/src/Dropdown.vue.d.ts

@@ -0,0 +1,66 @@
+import { PropType } from 'vue';
+import { DropMenu } from './typing';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    popconfirm: BooleanConstructor;
+    /**
+     * the trigger mode which executes the drop-down action
+     * @default ['hover']
+     * @type string[]
+     */
+    trigger: {
+        type: PropType<("contextmenu" | "click" | "hover")[]>;
+        default: () => string[];
+    };
+    dropMenuList: {
+        type: PropType<(DropMenu & IObject)[]>;
+        default: () => never[];
+    };
+    selectedKeys: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    menuEvent: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    popconfirm: BooleanConstructor;
+    /**
+     * the trigger mode which executes the drop-down action
+     * @default ['hover']
+     * @type string[]
+     */
+    trigger: {
+        type: PropType<("contextmenu" | "click" | "hover")[]>;
+        default: () => string[];
+    };
+    dropMenuList: {
+        type: PropType<(DropMenu & IObject)[]>;
+        default: () => never[];
+    };
+    selectedKeys: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+}>> & Readonly<{
+    onMenuEvent?: ((...args: any[]) => any) | undefined;
+}>, {
+    trigger: ("hover" | "click" | "contextmenu")[];
+    popconfirm: boolean;
+    dropMenuList: (DropMenu & IObject)[];
+    selectedKeys: string[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/components/v-ben-dropdown/src/Dropdown.vue.mjs

@@ -0,0 +1,5 @@
+import Dropdown_vue_vue_type_script_setup_true_lang_default from "./Dropdown.vue_vue_type_script_setup_true_lang.mjs";
+//#region src/components/v-ben-dropdown/src/Dropdown.vue
+var Dropdown_default = Dropdown_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { Dropdown_default as default };

package/es/components/v-ben-dropdown/src/Dropdown.vue_vue_type_script_setup_true_lang.mjs

@@ -0,0 +1,87 @@
+import { isFunction } from "../../../utils/is.mjs";
+import { Fragment, createBlock, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, mergeProps, openBlock, renderList, renderSlot, toDisplayString, unref, withCtx } from "vue";
+import { omit } from "lodash-es";
+import { Dropdown, Menu, Popconfirm } from "ant-design-vue";
+//#region src/components/v-ben-dropdown/src/Dropdown.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = { class: "ml-1" };
+var _hoisted_2 = {
+	key: 1,
+	class: "ml-1"
+};
+var Dropdown_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	name: "VDropdown",
+	__name: "Dropdown",
+	props: {
+		popconfirm: Boolean,
+		trigger: {
+			type: Array,
+			default: () => {
+				return ["contextmenu"];
+			}
+		},
+		dropMenuList: {
+			type: Array,
+			default: () => []
+		},
+		selectedKeys: {
+			type: Array,
+			default: () => []
+		}
+	},
+	emits: ["menuEvent"],
+	setup(__props, { emit: __emit }) {
+		const ADropdown = Dropdown;
+		const AMenu = Menu;
+		const AMenuItem = Menu.Item;
+		const AMenuDivider = Menu.Divider;
+		const APopconfirm = Popconfirm;
+		const props = __props;
+		const emit = __emit;
+		function handleClickMenu(item) {
+			const { event } = item;
+			emit("menuEvent", props.dropMenuList.find((item) => `${item.event}` === `${event}`));
+			item.onClick?.();
+		}
+		function getPopConfirmAttrs(attrs) {
+			const originAttrs = omit(attrs, [
+				"confirm",
+				"cancel",
+				"icon"
+			]);
+			if (!attrs.onConfirm && attrs.confirm && isFunction(attrs.confirm)) originAttrs["onConfirm"] = attrs.confirm;
+			if (!attrs.onCancel && attrs.cancel && isFunction(attrs.cancel)) originAttrs["onCancel"] = attrs.cancel;
+			return originAttrs;
+		}
+		const getAttr = (key) => ({ key });
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(ADropdown), mergeProps({ trigger: __props.trigger }, _ctx.$attrs), {
+				overlay: withCtx(() => [createVNode(unref(AMenu), { "selected-keys": __props.selectedKeys }, {
+					default: withCtx(() => [(openBlock(true), createElementBlock(Fragment, null, renderList(__props.dropMenuList, (item) => {
+						return openBlock(), createElementBlock(Fragment, { key: `${item.event}` }, [createVNode(unref(AMenuItem), mergeProps({ class: item.class }, { ref_for: true }, getAttr(item.event), {
+							disabled: item.disabled,
+							onClick: ($event) => handleClickMenu(item)
+						}), {
+							default: withCtx(() => [__props.popconfirm && item.popConfirm ? (openBlock(), createBlock(unref(APopconfirm), mergeProps({
+								key: 0,
+								ref_for: true
+							}, getPopConfirmAttrs(item.popConfirm)), {
+								default: withCtx(() => [createElementVNode("div", null, [createElementVNode("span", _hoisted_1, toDisplayString(item.text), 1)])]),
+								_: 2
+							}, 1040)) : (openBlock(), createElementBlock("span", _hoisted_2, toDisplayString(item.text), 1))]),
+							_: 2
+						}, 1040, [
+							"class",
+							"disabled",
+							"onClick"
+						]), item.divider ? (openBlock(), createBlock(unref(AMenuDivider), { key: `d-${item.event}` })) : createCommentVNode("", true)], 64);
+					}), 128))]),
+					_: 1
+				}, 8, ["selected-keys"])]),
+				default: withCtx(() => [createElementVNode("span", null, [renderSlot(_ctx.$slots, "default")]), createTextVNode(" " + toDisplayString(__props.dropMenuList) + " ", 1)]),
+				_: 3
+			}, 16, ["trigger"]);
+		};
+	}
+});
+//#endregion
+export { Dropdown_vue_vue_type_script_setup_true_lang_default as default };

package/es/components/v-ben-dropdown/src/typing.d.ts

@@ -0,0 +1,10 @@
+export interface DropMenu {
+    onClick?: Fn;
+    to?: string;
+    icon?: string;
+    event: string | number;
+    text: string;
+    disabled?: boolean;
+    divider?: boolean;
+    class?: string;
+}

package/es/components/v-ben-table/index.d.ts

@@ -0,0 +1,3 @@
+export { default as BasicTable } from './src/BasicTable.vue';
+export { default as TableAction } from './src/components/TableAction.vue';
+export { default as TableActionAuto } from './src/components/TableActionAuto.vue';

package/es/components/v-ben-table/index.mjs

@@ -0,0 +1,3 @@
+import "./src/BasicTable.vue.mjs";
+import "./src/components/TableAction.vue.mjs";
+import "./src/components/TableActionAuto.vue.mjs";

package/es/components/v-ben-table/src/BasicTable.vue.d.ts

@@ -0,0 +1,410 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    clickToRowSelect: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isTreeTable: BooleanConstructor;
+    tableSetting: {
+        type: import('vue').PropType<import('./types/table').TableSetting>;
+        default: {};
+    };
+    inset: BooleanConstructor;
+    showTableSetting: BooleanConstructor;
+    autoCreateKey: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    striped: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showSummary: BooleanConstructor;
+    summaryFunc: {
+        type: import('vue').PropType<(...arg: unknown[]) => unknown[]>;
+        default: null;
+    };
+    summaryData: {
+        type: import('vue').PropType<Recordable[]>;
+        default: null;
+    };
+    indentSize: {
+        type: NumberConstructor;
+        default: number;
+    };
+    canColDrag: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    api: {
+        type: import('vue').PropType<(...arg: unknown[]) => Promise<unknown>>;
+        default: null;
+    };
+    beforeFetch: {
+        type: import('vue').PropType<Fn>;
+        default: null;
+    };
+    afterFetch: {
+        type: import('vue').PropType<Fn>;
+        default: null;
+    };
+    handleSearchInfoFn: {
+        type: import('vue').PropType<Fn>;
+        default: null;
+    };
+    immediate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    emptyDataIsShowTable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    searchInfo: {
+        type: import('vue').PropType<Recordable>;
+        default: null;
+    };
+    defSort: {
+        type: import('vue').PropType<Recordable>;
+        default: null;
+    };
+    useSearchForm: BooleanConstructor;
+    columns: {
+        type: import('vue').PropType<import('./types/table').BasicColumn[]>;
+        default: () => never[];
+    };
+    showIndexColumn: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    indexColumnProps: {
+        type: import('vue').PropType<import('./types/table').BasicColumn>;
+        default: null;
+    };
+    actionColumn: {
+        type: import('vue').PropType<import('./types/table').BasicColumn>;
+        default: null;
+    };
+    ellipsis: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isCanResizeParent: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    canResize: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    clearSelectOnPageChange: BooleanConstructor;
+    resizeHeightOffset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    rowSelection: {
+        type: import('vue').PropType<import('./types/table').TableRowSelection | null>;
+        default: null;
+    };
+    title: {
+        type: import('vue').PropType<string | ((data: Recordable) => string)>;
+        default: null;
+    };
+    titleHelpMessage: {
+        type: import('vue').PropType<string | string[]>;
+    };
+    maxHeight: NumberConstructor;
+    dataSource: {
+        type: import('vue').PropType<Recordable[]>;
+        default: null;
+    };
+    rowKey: {
+        type: import('vue').PropType<string | ((record: Recordable) => string)>;
+        default: string;
+    };
+    bordered: BooleanConstructor;
+    pagination: {
+        type: import('vue').PropType<import('./types/pagination').PaginationProps | boolean>;
+        default: null;
+    };
+    loading: BooleanConstructor;
+    rowClassName: {
+        type: import('vue').PropType<(record: import('./types/table').TableCustomRecord<unknown>, index: number) => string>;
+    };
+    scroll: {
+        type: import('vue').PropType<{
+            x?: number | string | true;
+            y?: number | string;
+        }>;
+        default: null;
+    };
+    beforeEditSubmit: {
+        type: import('vue').PropType<(data: {
+            record: Recordable;
+            index: number;
+            key: string | number;
+            value: unknown;
+        }) => Promise<unknown>>;
+    };
+    rowDraggable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    supportSameLevel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    rowDragApi: {
+        type: FunctionConstructor;
+        default: null;
+    };
+    expandedRowKeys: {
+        type: import('vue').PropType<string[]>;
+        default: () => never[];
+    };
+    emptyFull: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {
+    formRef: import('vue').Ref<null, null>;
+    tableElRef: import('vue').Ref<null, null>;
+    getBindValues: import('vue').ComputedRef<IObject>;
+    handleTableChange: (...args: unknown[]) => void;
+    expandKeysList: import('vue').Ref<never[], never[]>;
+    getEmptyDataIsShowTable: import('vue').ComputedRef<boolean>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "change"[], "change", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    clickToRowSelect: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isTreeTable: BooleanConstructor;
+    tableSetting: {
+        type: import('vue').PropType<import('./types/table').TableSetting>;
+        default: {};
+    };
+    inset: BooleanConstructor;
+    showTableSetting: BooleanConstructor;
+    autoCreateKey: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    striped: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showSummary: BooleanConstructor;
+    summaryFunc: {
+        type: import('vue').PropType<(...arg: unknown[]) => unknown[]>;
+        default: null;
+    };
+    summaryData: {
+        type: import('vue').PropType<Recordable[]>;
+        default: null;
+    };
+    indentSize: {
+        type: NumberConstructor;
+        default: number;
+    };
+    canColDrag: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    api: {
+        type: import('vue').PropType<(...arg: unknown[]) => Promise<unknown>>;
+        default: null;
+    };
+    beforeFetch: {
+        type: import('vue').PropType<Fn>;
+        default: null;
+    };
+    afterFetch: {
+        type: import('vue').PropType<Fn>;
+        default: null;
+    };
+    handleSearchInfoFn: {
+        type: import('vue').PropType<Fn>;
+        default: null;
+    };
+    immediate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    emptyDataIsShowTable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    searchInfo: {
+        type: import('vue').PropType<Recordable>;
+        default: null;
+    };
+    defSort: {
+        type: import('vue').PropType<Recordable>;
+        default: null;
+    };
+    useSearchForm: BooleanConstructor;
+    columns: {
+        type: import('vue').PropType<import('./types/table').BasicColumn[]>;
+        default: () => never[];
+    };
+    showIndexColumn: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    indexColumnProps: {
+        type: import('vue').PropType<import('./types/table').BasicColumn>;
+        default: null;
+    };
+    actionColumn: {
+        type: import('vue').PropType<import('./types/table').BasicColumn>;
+        default: null;
+    };
+    ellipsis: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isCanResizeParent: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    canResize: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    clearSelectOnPageChange: BooleanConstructor;
+    resizeHeightOffset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    rowSelection: {
+        type: import('vue').PropType<import('./types/table').TableRowSelection | null>;
+        default: null;
+    };
+    title: {
+        type: import('vue').PropType<string | ((data: Recordable) => string)>;
+        default: null;
+    };
+    titleHelpMessage: {
+        type: import('vue').PropType<string | string[]>;
+    };
+    maxHeight: NumberConstructor;
+    dataSource: {
+        type: import('vue').PropType<Recordable[]>;
+        default: null;
+    };
+    rowKey: {
+        type: import('vue').PropType<string | ((record: Recordable) => string)>;
+        default: string;
+    };
+    bordered: BooleanConstructor;
+    pagination: {
+        type: import('vue').PropType<import('./types/pagination').PaginationProps | boolean>;
+        default: null;
+    };
+    loading: BooleanConstructor;
+    rowClassName: {
+        type: import('vue').PropType<(record: import('./types/table').TableCustomRecord<unknown>, index: number) => string>;
+    };
+    scroll: {
+        type: import('vue').PropType<{
+            x?: number | string | true;
+            y?: number | string;
+        }>;
+        default: null;
+    };
+    beforeEditSubmit: {
+        type: import('vue').PropType<(data: {
+            record: Recordable;
+            index: number;
+            key: string | number;
+            value: unknown;
+        }) => Promise<unknown>>;
+    };
+    rowDraggable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    supportSameLevel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    rowDragApi: {
+        type: FunctionConstructor;
+        default: null;
+    };
+    expandedRowKeys: {
+        type: import('vue').PropType<string[]>;
+        default: () => never[];
+    };
+    emptyFull: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onChange?: ((...args: any[]) => any) | undefined;
+}>, {
+    title: string | ((data: Recordable) => string);
+    clickToRowSelect: boolean;
+    isTreeTable: boolean;
+    tableSetting: import('./types/table').TableSetting;
+    inset: boolean;
+    showTableSetting: boolean;
+    autoCreateKey: boolean;
+    striped: boolean;
+    showSummary: boolean;
+    summaryFunc: (...arg: unknown[]) => unknown[];
+    summaryData: Recordable<unknown>[];
+    indentSize: number;
+    canColDrag: boolean;
+    api: (...arg: unknown[]) => Promise<unknown>;
+    beforeFetch: Fn<any, any>;
+    afterFetch: Fn<any, any>;
+    handleSearchInfoFn: Fn<any, any>;
+    immediate: boolean;
+    emptyDataIsShowTable: boolean;
+    searchInfo: Recordable<unknown>;
+    defSort: Recordable<unknown>;
+    useSearchForm: boolean;
+    columns: import('./types/table').BasicColumn[];
+    showIndexColumn: boolean;
+    indexColumnProps: import('./types/table').BasicColumn;
+    actionColumn: import('./types/table').BasicColumn;
+    ellipsis: boolean;
+    isCanResizeParent: boolean;
+    canResize: boolean;
+    clearSelectOnPageChange: boolean;
+    resizeHeightOffset: number;
+    rowSelection: import('./types/table').TableRowSelection<unknown> | null;
+    dataSource: Recordable<unknown>[];
+    rowKey: string | ((record: Recordable) => string);
+    bordered: boolean;
+    pagination: boolean | import('./types/pagination').PaginationProps;
+    loading: boolean;
+    scroll: {
+        x?: number | string | true;
+        y?: number | string;
+    };
+    rowDraggable: boolean;
+    supportSameLevel: boolean;
+    rowDragApi: Function;
+    expandedRowKeys: string[];
+    emptyFull: boolean;
+}, {}, {
+    HeaderCell: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        column: {
+            type: import('vue').PropType<import('./types/table').BasicColumn>;
+            default: () => {};
+        };
+    }>, {
+        getTitle: import('vue').ComputedRef<string | number | boolean | void | import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+            [key: string]: any;
+        }> | import('vue').VNodeArrayChildren | ((props: import('ant-design-vue/lib/table/interface').ColumnTitleProps<Recordable<unknown>>) => import('ant-design-vue/lib/_util/type').VueNode) | null>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        column: {
+            type: import('vue').PropType<import('./types/table').BasicColumn>;
+            default: () => {};
+        };
+    }>> & Readonly<{}>, {
+        column: import('./types/table').BasicColumn;
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/es/components/v-ben-table/src/BasicTable.vue.mjs

@@ -0,0 +1,37 @@
+import _plugin_vue_export_helper_default from "../../../_virtual/_plugin-vue_export-helper.mjs";
+import BasicTable_vue_vue_type_script_lang_default from "./BasicTable.vue_vue_type_script_lang.mjs";
+import { Fragment, createBlock, createElementBlock, createSlots, createVNode, guardReactiveProps, mergeProps, normalizeProps, openBlock, renderList, renderSlot, resolveComponent, vShow, withCtx, withDirectives } from "vue";
+//#region src/components/v-ben-table/src/BasicTable.vue
+var _hoisted_1 = { ref: "wrapRef" };
+var _hoisted_2 = {
+	key: 0,
+	class: "pr26px"
+};
+var _hoisted_3 = {
+	key: 1,
+	class: "pr8px"
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+	const _component_HeaderCell = resolveComponent("HeaderCell");
+	const _component_a_table = resolveComponent("a-table");
+	return openBlock(), createElementBlock("div", _hoisted_1, [renderSlot(_ctx.$slots, "beforeTable"), withDirectives(createVNode(_component_a_table, mergeProps({ ref: "tableElRef" }, _ctx.getBindValues, {
+		"expanded-row-keys": _ctx.expandKeysList,
+		"onUpdate:expandedRowKeys": _cache[0] || (_cache[0] = ($event) => _ctx.expandKeysList = $event),
+		onChange: _ctx.handleTableChange
+	}), createSlots({
+		headerCell: withCtx(({ column }) => [_ctx.rowDraggable && column?.dataIndex === _ctx.getBindValues.columns[0].dataIndex ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [_ctx.isTreeTable ? (openBlock(), createElementBlock("span", _hoisted_2)) : (openBlock(), createElementBlock("span", _hoisted_3)), createVNode(_component_HeaderCell, { column }, null, 8, ["column"])], 64)) : (openBlock(), createBlock(_component_HeaderCell, {
+			key: 1,
+			column
+		}, null, 8, ["column"]))]),
+		bodyCell: withCtx((data) => [renderSlot(_ctx.$slots, "bodyCell", normalizeProps(guardReactiveProps(data || {})))]),
+		_: 2
+	}, [renderList(Object.keys(_ctx.$slots), (item) => {
+		return {
+			name: item,
+			fn: withCtx((data) => [renderSlot(_ctx.$slots, item, normalizeProps(guardReactiveProps(data || {})))])
+		};
+	})]), 1040, ["expanded-row-keys", "onChange"]), [[vShow, _ctx.getEmptyDataIsShowTable]])], 512);
+}
+var BasicTable_default = /* @__PURE__ */ _plugin_vue_export_helper_default(BasicTable_vue_vue_type_script_lang_default, [["render", _sfc_render]]);
+//#endregion
+export { BasicTable_default as default };

package/es/components/v-ben-table/src/BasicTable.vue_vue_type_script_lang.mjs

@@ -0,0 +1,41 @@
+import HeaderCell_default from "./components/HeaderCell.vue.mjs";
+import { basicProps } from "./props.mjs";
+import { computed, defineComponent, ref } from "vue";
+import { omit } from "lodash-es";
+//#region src/components/v-ben-table/src/BasicTable.vue?vue&type=script&lang.ts
+var BasicTable_vue_vue_type_script_lang_default = defineComponent({
+	name: "BasicTable",
+	components: { HeaderCell: HeaderCell_default },
+	props: basicProps,
+	emits: ["change"],
+	setup(props, { attrs, emit, slots, expose }) {
+		const tableElRef = ref(null);
+		const expandKeysList = ref([]);
+		const formRef = ref(null);
+		const getBindValues = computed(() => {
+			let propsData = { ...attrs };
+			propsData = omit(propsData, ["class", "onChange"]);
+			return propsData;
+		});
+		function handleTableChange(...args) {
+			emit("change", ...args);
+		}
+		return {
+			formRef,
+			tableElRef,
+			getBindValues,
+			handleTableChange,
+			expandKeysList,
+			getEmptyDataIsShowTable: computed(() => {
+				const { emptyDataIsShowTable, useSearchForm, dataSource } = props;
+				if (emptyDataIsShowTable || !useSearchForm) return true;
+				return !!dataSource.length;
+			})
+		};
+	},
+	mounted() {
+		this.expandKeysList = this.getBindValues.expandedRowKeys;
+	}
+});
+//#endregion
+export { BasicTable_vue_vue_type_script_lang_default as default };

package/es/components/v-ben-table/src/components/HeaderCell.vue.d.ts

@@ -0,0 +1,20 @@
+import { PropType } from 'vue';
+import { BasicColumn } from '../types/table';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    column: {
+        type: PropType<BasicColumn>;
+        default: () => {};
+    };
+}>, {
+    getTitle: import('vue').ComputedRef<string | number | boolean | void | import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+        [key: string]: any;
+    }> | import('vue').VNodeArrayChildren | ((props: import('ant-design-vue/lib/table/interface').ColumnTitleProps<Recordable<unknown>>) => import('ant-design-vue/lib/_util/type').VueNode) | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    column: {
+        type: PropType<BasicColumn>;
+        default: () => {};
+    };
+}>> & Readonly<{}>, {
+    column: BasicColumn;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;