@gx-design-vue/pro-table 0.2.0-alpha.7 → 0.2.0-alpha.9

package/dist/hooks/useTableForm.d.ts

@@ -1,87 +1,19 @@
-import { ProFieldValueFormat, ProFieldValueType, ProSchemaValueEnumType, ProSearchMap } from "../types/ColumnTypings.js";
-import { ProTableProps } from "../types/TableTypings.js";
+import { ProColumnType, ProSearchMap } from "../interface.js";
 import { ComputedRef, Ref } from "vue";
-import { RecordType } from "@gx-design-vue/pro-utils";
 
 //#region src/hooks/useTableForm.d.ts
-declare function handleFormDefaultValue(data: ProSearchMap[]): RecordType;
-declare function useTableForm({
-  searchMap,
-  columns
-}: {
-  searchMap: Ref<ProTableProps['searchMap']>;
-  columns: ComputedRef<ProTableProps['columns']>;
-}): {
-  formCols: Ref<{
-    name: string;
-    order?: number;
-    valueType?: ProFieldValueType;
-    valueFormat?: ProFieldValueFormat;
-    placeholder?: string | string[];
-    allowClear?: boolean;
-    showSearch?: boolean;
-    showToday?: boolean;
-    rangeStartName?: string;
-    rangeEndName?: string;
-    use12Hours?: boolean;
-    loading?: boolean;
-    showTime?: RecordType | boolean;
-    initialValue?: any;
-    valueKey?: string;
-    request?: {
-      fetch?: () => Promise<ProSchemaValueEnumType[]>;
-      manual?: boolean;
-      debounceTime?: number;
-    };
-    label?: string;
-    labelWidth?: string | number;
-    labelAlign?: "center" | "left" | "right";
-    field?: {
-      [x: string]: any;
-      rules?: RegExp;
-    };
-    valueEnum?: {
-      [x: string]: any;
-      label: any;
-      value: any;
-      disabled?: boolean;
-    }[];
-  }[], ProSearchMap<"text", string>[] | {
-    name: string;
-    order?: number;
-    valueType?: ProFieldValueType;
-    valueFormat?: ProFieldValueFormat;
-    placeholder?: string | string[];
-    allowClear?: boolean;
-    showSearch?: boolean;
-    showToday?: boolean;
-    rangeStartName?: string;
-    rangeEndName?: string;
-    use12Hours?: boolean;
-    loading?: boolean;
-    showTime?: RecordType | boolean;
-    initialValue?: any;
-    valueKey?: string;
-    request?: {
-      fetch?: () => Promise<ProSchemaValueEnumType[]>;
-      manual?: boolean;
-      debounceTime?: number;
-    };
-    label?: string;
-    labelWidth?: string | number;
-    labelAlign?: "center" | "left" | "right";
-    field?: {
-      [x: string]: any;
-      rules?: RegExp;
-    };
-    valueEnum?: {
-      [x: string]: any;
-      label: any;
-      value: any;
-      disabled?: boolean;
-    }[];
-  }[]>;
-  defaultFormSearch: Ref<RecordType, RecordType>;
-};
+interface UseTableFormOptions {
+  searchMap: ComputedRef<ProSearchMap[]>;
+  columns: ComputedRef<ProColumnType[]>;
+}
+interface UseTableFormReturn {
+  formColumns: ComputedRef<ProSearchMap[]>;
+  defaultFormSearch: Ref<Record<string, any>>;
+  formState: Ref<Record<string, any>>;
+  getFormSearch: () => Record<string, any>;
+  resetFormState: () => void;
+  changeFormState: (key: string, value: any) => void;
+}
+declare function useTableForm(options: UseTableFormOptions): UseTableFormReturn;
 //#endregion
-export { handleFormDefaultValue, useTableForm };
+export { UseTableFormOptions, UseTableFormReturn, useTableForm };

package/dist/hooks/useTableForm.js

@@ -1,70 +1,107 @@
-import { ref, watch } from "vue";
-import { isArray } from "@gx-design-vue/pro-utils";
+import { computed, ref, toRaw, watch } from "vue";
+import { cloneDeep } from "@gx-design-vue/pro-utils";
 //#region src/hooks/useTableForm.ts
-function handleFormDefaultValue(data) {
-	const defaulState = {};
-	data.forEach((item) => {
-		let initialValue = item.initialValue;
-		const valueEmptyArray = ["numberRange"];
-		if (item.valueType) {
-			if (!initialValue) {
-				if (valueEmptyArray.includes(item.valueType)) initialValue = [];
-				else if (item.valueType === "treeSelect" && (item.field?.multiple || item.field?.treeCheckable)) initialValue = [];
-			}
-		}
-		if (item.name) defaulState[item.name] = initialValue;
-		if (item.valueType === "dateRange") {
-			if (item.rangeStartName || item.rangeEndName) {
-				defaulState[item.rangeStartName || "start"] = isArray(initialValue) ? initialValue[0] : void 0;
-				defaulState[item.rangeEndName || "end"] = isArray(initialValue) ? initialValue[1] : void 0;
-				delete defaulState[item.name];
-			}
+function sortFormItemsByOrder(items) {
+	let maxOrder = items.reduce((max, item) => {
+		return item.order !== void 0 ? Math.max(max, item.order) : max;
+	}, 0);
+	const sorted = items.map((item) => {
+		if (item.order === void 0) {
+			maxOrder += 1;
+			return {
+				...item,
+				order: maxOrder
+			};
 		}
+		return item;
 	});
-	return defaulState;
+	sorted.sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+	return sorted;
 }
-function useTableForm({ searchMap, columns }) {
-	const formCols = ref([]);
-	const defaultFormSearch = ref({});
-	function updateFormData(data) {
-		data.forEach((item) => {
-			if (formCols.value.some((el) => el.name === item.name)) formCols.value = formCols.value.map((el) => {
-				if (el.name === item.name) return {
-					...el,
-					...item
-				};
-				return el;
-			});
-			else formCols.value.push(item);
-		});
-		const defaultParams = handleFormDefaultValue(data);
-		defaultFormSearch.value = {
-			...defaultFormSearch.value,
-			...defaultParams
-		};
+function computeDefaultFormValues(columns) {
+	const defaults = {};
+	for (const col of columns) {
+		const valueType = col.valueType ?? "text";
+		if (col.initialValue !== void 0) defaults[col.name] = col.initialValue;
+		else if (valueType === "numberRange") defaults[col.name] = [];
+		else if (valueType === "treeSelect" && (col.field?.treeCheckable || col.field?.multiple)) defaults[col.name] = [];
+		else if (valueType === "cascader" && col.field?.multiple) defaults[col.name] = [];
+		else if (valueType === "dateRange") if (col.rangeStartName || col.rangeEndName) {
+			defaults[col.rangeStartName || "start"] = void 0;
+			defaults[col.rangeEndName || "end"] = void 0;
+		} else defaults[col.name] = void 0;
 	}
-	watch(() => searchMap.value, () => {
-		const searchData = [];
-		searchMap.value?.forEach((item) => searchData.push(item));
-		if (searchData.length) updateFormData(searchData);
-	}, {
-		deep: true,
-		immediate: true
+	return defaults;
+}
+function useTableForm(options) {
+	const { searchMap, columns } = options;
+	const formColumns = computed(() => {
+		const colsFromSearchMap = searchMap.value;
+		const colsFromColumns = columns.value.filter((col) => col.searchConfig).map((col) => ({
+			...col.searchConfig,
+			order: col.searchConfig.order ?? col.order ?? 0
+		}));
+		return sortFormItemsByOrder([...colsFromSearchMap, ...colsFromColumns]);
 	});
-	watch(() => columns.value, () => {
-		const searchData = [];
-		if (columns.value && columns.value?.length) columns.value.forEach((item) => {
-			if (item.searchConfig) searchData.push(item.searchConfig);
-		});
-		if (searchData.length) updateFormData(searchData);
+	const defaultFormSearch = computed(() => {
+		return computeDefaultFormValues(formColumns.value);
+	});
+	const formState = ref({});
+	watch(() => defaultFormSearch.value, (newDefaults) => {
+		formState.value = cloneDeep(toRaw(newDefaults));
 	}, {
 		deep: true,
 		immediate: true
 	});
+	function getFormSearch() {
+		const searchParams = cloneDeep(toRaw(formState.value));
+		for (const record of formColumns.value) {
+			const valueType = record.valueType ?? "text";
+			const name = record.name;
+			if (valueType === "text") searchParams[name] = formState.value[name] ?? record.initialValue;
+			if (valueType === "dateRange" && (record.rangeStartName || record.rangeEndName)) {
+				const rangeValue = searchParams[name];
+				searchParams[record.rangeStartName || "start"] = Array.isArray(rangeValue) ? rangeValue[0] : void 0;
+				searchParams[record.rangeEndName || "end"] = Array.isArray(rangeValue) ? rangeValue[1] : void 0;
+				delete searchParams[name];
+			}
+			if (valueType === "cascader" && record.valueKey === "single") {
+				const value = searchParams[name];
+				searchParams[name] = Array.isArray(value) ? value[value.length - 1] : void 0;
+			}
+			if (valueType === "treeSelect" && Array.isArray(formState.value[name])) {
+				const keyField = record.valueKey === "text" ? "label" : "value";
+				searchParams[name] = formState.value[name].length > 0 ? formState.value[name].map((item) => item[keyField]).join(",") : void 0;
+			}
+			if (valueType === "numberRange") {
+				const value = searchParams[name];
+				searchParams[name] = Array.isArray(value) && value.some((val) => val !== void 0 && val !== null && val !== "") ? value : void 0;
+			}
+		}
+		return searchParams;
+	}
+	function resetFormState() {
+		const defaults = cloneDeep(toRaw(defaultFormSearch.value));
+		formState.value = defaults;
+		for (const record of formColumns.value) if (record.valueType === "dateRange" && (record.rangeStartName || record.rangeEndName)) {
+			const startKey = record.rangeStartName || "start";
+			const endKey = record.rangeEndName || "end";
+			const startValue = defaults[startKey];
+			const endValue = defaults[endKey];
+			if (startValue !== void 0 || endValue !== void 0) formState.value[record.name] = [startValue, endValue];
+		}
+	}
+	function changeFormState(key, value) {
+		if (key) formState.value[key] = value;
+	}
 	return {
-		formCols,
-		defaultFormSearch
+		formColumns,
+		defaultFormSearch,
+		formState,
+		getFormSearch,
+		resetFormState,
+		changeFormState
 	};
 }
 //#endregion
-export { handleFormDefaultValue, useTableForm };
+export { useTableForm };

package/dist/hooks/useTableScroll.d.ts

@@ -1,35 +1,37 @@
-import { ProColumnsType } from "../types/ColumnTypings.js";
-import { ProTableProps, TableScroll } from "../types/TableTypings.js";
-import { ComputedRef, Ref } from "vue";
-import { Breakpoint } from "@gx-design-vue/pro-utils";
+import { ProColumnType, ProTableScrollPolicy } from "../interface.js";
+import { ComputedRef } from "vue";
+import { Breakpoint, RecordType } from "@gx-design-vue/pro-utils";
+import { TableProps } from "antdv-next";
 
 //#region src/hooks/useTableScroll.d.ts
-interface ConfigScroll {
-  scroll: Ref<ProTableProps['scroll']>;
-  autoScroll: Ref<ProTableProps['autoScroll']>;
-  modalScroll: Ref<ProTableProps['modalScroll']>;
-  neverScroll: Ref<ProTableProps['neverScroll']>;
-  rowSelection: Ref<ProTableProps['rowSelection']>;
-  scrollBreakpoint: Ref<ProTableProps['scrollBreakpoint']>;
+interface NormalizedTableScrollPolicy {
+  mode: 'auto' | 'manual' | 'disabled';
+  breakpoint: Breakpoint | number;
+  modal: boolean;
+  modalY: {
+    desktop: number;
+    mobile: number;
+  };
+  actionFixed: boolean | 'auto';
 }
-type useTableScrollType = {
-  columns: ComputedRef<ProColumnsType>;
-  innerWidth: Ref<number>;
-  screens: Ref<Partial<Record<Breakpoint, boolean>>>;
-} & ConfigScroll;
-declare function useTableScroll({
-  scroll,
-  columns,
-  autoScroll,
-  modalScroll,
-  neverScroll,
-  rowSelection,
-  screens,
-  innerWidth,
-  scrollBreakpoint
-}: useTableScrollType): {
-  proScroll: ComputedRef<TableScroll>;
-  breakpoint: ComputedRef<boolean>;
-};
+interface UseTableScrollOptions<T = RecordType> {
+  scroll: ComputedRef<TableProps<T>['scroll'] | undefined>;
+  columns: ComputedRef<ProColumnType<T>[]>;
+  rowSelection: ComputedRef<TableProps<T>['rowSelection'] | undefined>;
+  screens: ComputedRef<Record<string, boolean>>;
+  screenWidth: ComputedRef<number>;
+  scrollPolicy: ComputedRef<false | ProTableScrollPolicy | undefined>;
+}
+interface UseTableScrollReturn<T = RecordType> {
+  tableScroll: ComputedRef<TableProps<T>['scroll']>;
+  hasHorizontalScroll: ComputedRef<boolean>;
+  shouldFixActionColumn: ComputedRef<boolean>;
+  normalizedScrollPolicy: ComputedRef<NormalizedTableScrollPolicy>;
+}
+declare function normalizeScrollPolicy(scrollPolicy: false | ProTableScrollPolicy | undefined): NormalizedTableScrollPolicy;
+declare function isLargeScreenByBreakpoint(breakpoint: Breakpoint | number, screens: Record<string, boolean>, screenWidth: number): boolean;
+declare function getColumnWidthValue(column: ProColumnType<any>): number;
+declare function getTableScrollX(columns: ProColumnType<any>[], hasRowSelection: boolean): number;
+declare function useTableScroll<T = RecordType>(options: UseTableScrollOptions<T>): UseTableScrollReturn<T>;
 //#endregion
-export { useTableScroll };
+export { NormalizedTableScrollPolicy, UseTableScrollOptions, UseTableScrollReturn, getColumnWidthValue, getTableScrollX, isLargeScreenByBreakpoint, normalizeScrollPolicy, useTableScroll };

package/dist/hooks/useTableScroll.js

@@ -1,34 +1,79 @@
-import { computed, unref } from "vue";
-import { cloneDeep, isBoolean, isNumber, isString, keysOf } from "@gx-design-vue/pro-utils";
+import { computed } from "vue";
 //#region src/hooks/useTableScroll.ts
-function useTableScroll({ scroll, columns, autoScroll, modalScroll, neverScroll, rowSelection, screens, innerWidth, scrollBreakpoint }) {
-	const breakpoint = computed(() => {
-		if (scrollBreakpoint.value) return isNumber(scrollBreakpoint.value) ? innerWidth.value > scrollBreakpoint.value : isString(scrollBreakpoint.value) ? screens.value?.[scrollBreakpoint.value] : screens.value?.xl;
-		return screens.value?.xl;
+const DEFAULT_COLUMN_WIDTH = 150;
+const ROW_SELECTION_WIDTH = 60;
+const DEFAULT_MODAL_SCROLL_Y = {
+	desktop: 400,
+	mobile: 235
+};
+function normalizeScrollPolicy(scrollPolicy) {
+	if (scrollPolicy === false) return {
+		mode: "disabled",
+		breakpoint: "xl",
+		modal: false,
+		modalY: DEFAULT_MODAL_SCROLL_Y,
+		actionFixed: false
+	};
+	const modalY = typeof scrollPolicy?.modalY === "number" ? {
+		desktop: scrollPolicy.modalY,
+		mobile: scrollPolicy.modalY
+	} : {
+		desktop: scrollPolicy?.modalY?.desktop ?? DEFAULT_MODAL_SCROLL_Y.desktop,
+		mobile: scrollPolicy?.modalY?.mobile ?? DEFAULT_MODAL_SCROLL_Y.mobile
+	};
+	const mode = scrollPolicy?.mode ?? "auto";
+	return {
+		mode,
+		breakpoint: scrollPolicy?.breakpoint ?? "xl",
+		modal: mode === "auto" ? !!scrollPolicy?.modal : false,
+		modalY,
+		actionFixed: mode === "disabled" ? false : scrollPolicy?.actionFixed ?? "auto"
+	};
+}
+function isLargeScreenByBreakpoint(breakpoint, screens, screenWidth) {
+	return typeof breakpoint === "number" ? screenWidth >= breakpoint : !!screens[breakpoint];
+}
+function getColumnWidthValue(column) {
+	const width = Number.parseInt(String(column.width ?? ""), 10);
+	return Number.isFinite(width) && width > 0 ? width : DEFAULT_COLUMN_WIDTH;
+}
+function getTableScrollX(columns, hasRowSelection) {
+	return columns.reduce((total, column) => {
+		return total + getColumnWidthValue(column);
+	}, 0) + (hasRowSelection ? ROW_SELECTION_WIDTH : 0);
+}
+function useTableScroll(options) {
+	const normalizedScrollPolicy = computed(() => normalizeScrollPolicy(options.scrollPolicy.value));
+	const isLargeScreen = computed(() => {
+		const policy = normalizedScrollPolicy.value;
+		return isLargeScreenByBreakpoint(policy.breakpoint, options.screens.value, options.screenWidth.value);
+	});
+	const autoScrollX = computed(() => {
+		return getTableScrollX(options.columns.value, !!options.rowSelection.value);
+	});
+	const tableScroll = computed(() => {
+		const policy = normalizedScrollPolicy.value;
+		const explicitScroll = options.scroll.value;
+		if (policy.mode === "disabled") return {};
+		if (policy.mode === "manual") return explicitScroll ?? {};
+		const nextScroll = { ...explicitScroll ?? {} };
+		if (!nextScroll.x && !isLargeScreen.value) nextScroll.x = autoScrollX.value;
+		if (policy.modal && !nextScroll.y) nextScroll.y = isLargeScreen.value ? policy.modalY.desktop : policy.modalY.mobile;
+		return nextScroll;
 	});
-	const scrollX = computed(() => {
-		let width = 0;
-		const rowSelectWidth = unref(rowSelection) ? 60 : 0;
-		const NORMAL_WIDTH = 150;
-		const viewColumns = cloneDeep(unref(columns));
-		viewColumns.forEach((item) => {
-			width += Number.parseInt(String(item.width)) || 0;
-		});
-		const len = viewColumns.filter((item) => !Reflect.has(item, "width")).length;
-		if (len !== 0) width += len * NORMAL_WIDTH;
-		if (rowSelectWidth) width += rowSelectWidth;
-		return width;
+	const hasHorizontalScroll = computed(() => {
+		return !!tableScroll.value?.x;
 	});
 	return {
-		proScroll: computed(() => {
-			if (neverScroll.value) return {};
-			if (scroll.value && keysOf(scroll.value).length) return unref(scroll);
-			if (modalScroll.value) return { y: scroll.value?.y || (screens.value?.xl ? 400 : 235) };
-			if (!autoScroll.value) return {};
-			return breakpoint.value ? {} : isBoolean(breakpoint.value) ? { x: scrollX.value } : {};
+		tableScroll,
+		hasHorizontalScroll,
+		shouldFixActionColumn: computed(() => {
+			const policy = normalizedScrollPolicy.value;
+			if (policy.mode === "disabled" || policy.actionFixed === false) return false;
+			return hasHorizontalScroll.value;
 		}),
-		breakpoint
+		normalizedScrollPolicy
 	};
 }
 //#endregion
-export { useTableScroll };
+export { getColumnWidthValue, getTableScrollX, isLargeScreenByBreakpoint, normalizeScrollPolicy, useTableScroll };

package/dist/hooks/useTableSize.d.ts

@@ -1,10 +1,20 @@
-import { Ref } from "vue";
-import { SizeType } from "@gx-design-vue/pro-utils";
+import { ProTableSizeType } from "../interface.js";
+import { ComputedRef } from "vue";
 
 //#region src/hooks/useTableSize.d.ts
-declare function useTableSize(options: {
-  size: Ref<SizeType>;
-  onChange: (value: SizeType) => void;
-}): [Ref<SizeType>, (value: SizeType) => void];
+interface UseTableSizeOptions {
+  size: ComputedRef<ProTableSizeType | undefined>;
+  onChange?: (size: ProTableSizeType) => void;
+}
+interface UseTableSizeReturn {
+  tableSize: ComputedRef<ProTableSizeType>;
+  setTableSize: (size: ProTableSizeType) => void;
+}
+/**
+ * Table 尺寸状态管理。
+ * 纯 computed 实现，无 ref + watch 链。
+ * setTableSize 校验合法值后才触发 onChange 回调。
+ */
+declare function useTableSize(options: UseTableSizeOptions): UseTableSizeReturn;
 //#endregion
-export { useTableSize };
+export { UseTableSizeOptions, UseTableSizeReturn, useTableSize };

package/dist/hooks/useTableSize.js

@@ -1,12 +1,26 @@
-import { ref, watch } from "vue";
+import { computed } from "vue";
 //#region src/hooks/useTableSize.ts
+const VALID_SIZES = new Set([
+	"small",
+	"medium",
+	"middle",
+	"large"
+]);
+const DEFAULT_SIZE = "middle";
+/**
+* Table 尺寸状态管理。
+* 纯 computed 实现，无 ref + watch 链。
+* setTableSize 校验合法值后才触发 onChange 回调。
+*/
 function useTableSize(options) {
-	const tableSize = ref(options.size.value || "middle");
-	watch(() => options.size.value, (value) => tableSize.value = value);
-	function setTableSize(value) {
-		tableSize.value = value || tableSize.value;
+	const tableSize = computed(() => options.size.value ?? DEFAULT_SIZE);
+	function setTableSize(size) {
+		if (VALID_SIZES.has(size)) options.onChange?.(size);
 	}
-	return [tableSize, setTableSize];
+	return {
+		tableSize,
+		setTableSize
+	};
 }
 //#endregion
 export { useTableSize };

package/dist/index.d.ts

@@ -1,7 +1,10 @@
-import { ProColumnType, ProColumnsType, ProFieldValueType, ProSchemaValueEnumType, ProSearchMap } from "./types/ColumnTypings.js";
-import { CustomRenderResult, ProTableBodyCellProps, TableSlots } from "./types/SlotsTypings.js";
-import { FormConfig, OptionConfig, PageState, ProCoreActionType, ProCoreFormType, ProTableFetchParams, ProTablePaginationConfig, ProTableProps, ProTableRef, RequestConfig, RequestFunction } from "./types/TableTypings.js";
-import { BaseTableProps, proTableProps } from "./props.js";
-import { BaseTableState, ProTableState, UseTableReturn, useTable } from "./hooks/useTable.js";
-import ProTable from "./ProTable.js";
-export { type BaseTableProps, BaseTableState, type CustomRenderResult, type FormConfig, ProTable as GProTable, type OptionConfig, type PageState, type ProColumnType, type ProColumnsType, type ProCoreActionType, type ProCoreFormType, type ProFieldValueType, type ProSchemaValueEnumType, type ProSearchMap, type ProTableBodyCellProps, type ProTableFetchParams, type ProTablePaginationConfig, type ProTableProps, type ProTableRef, ProTableState, type RequestConfig, type RequestFunction, type TableSlots, UseTableReturn, proTableProps, useTable };
+import { BeforeSearchSubmit, ColConfig, ColumnWithKeyOrDataIndex, CustomDataFn, CustomDataRender, CustomRenderResult, DefaultProColumn, DefaultProColumnWithKeyOrDataIndex, DefaultRender, FormConfig, OperateRowProps, PageItemFn, PageItemRender, PageState, ProColumn, ProColumnType, ProColumnsValueType, ProCoreActionType, ProFieldValueFormat, ProFieldValueType, ProSchemaValueEnumType, ProSearchMap, ProTableBodyCellProps, ProTableClassNamesType, ProTableCustomProps, ProTableEmits, ProTableFetchParams, ProTableIndexColumn, ProTablePagination, ProTablePaginationConfig, ProTableProps, ProTableRef, ProTableScrollPolicy, ProTableSizeType, ProTableSlots, ProTableStylesType, RequestConfig, RequestData, RequestFunction, RowSelectionActions, TableSemanticName, TableSorterRecord, ToolbarOptionConfig, ToolbarPlacement } from "./interface.js";
+import _default from "./ProTable.js";
+import { useInjectTableContext } from "./context/TableContext.js";
+import { UseProBreakpointsReturn, useProBreakpoints } from "./hooks/useBreakpoints.js";
+import { FetchDataAction, FetchDataConfig, useFetchData } from "./hooks/useFetchData.js";
+import { usePagination } from "./hooks/usePagination.js";
+import { UseRequestOptionsParams, UseRequestOptionsReturn, useRequestOptions } from "./hooks/useRequestOptions.js";
+import { UseTableOptions, UseTableReturn, useTable } from "./hooks/useTable.js";
+import { UseTableFormOptions, UseTableFormReturn, useTableForm } from "./hooks/useTableForm.js";
+export { BeforeSearchSubmit, ColConfig, ColumnWithKeyOrDataIndex, CustomDataFn, CustomDataRender, CustomRenderResult, DefaultProColumn, DefaultProColumnWithKeyOrDataIndex, DefaultRender, type FetchDataAction, type FetchDataConfig, FormConfig, _default as GProTable, OperateRowProps, PageItemFn, PageItemRender, PageState, ProColumn, ProColumnType, ProColumnsValueType, ProCoreActionType, ProFieldValueFormat, ProFieldValueType, ProSchemaValueEnumType, ProSearchMap, ProTableBodyCellProps, ProTableClassNamesType, ProTableCustomProps, ProTableEmits, ProTableFetchParams, ProTableIndexColumn, ProTablePagination, ProTablePaginationConfig, ProTableProps, ProTableRef, ProTableScrollPolicy, ProTableSizeType, ProTableSlots, ProTableStylesType, RequestConfig, RequestData, RequestFunction, RowSelectionActions, TableSemanticName, TableSorterRecord, ToolbarOptionConfig, ToolbarPlacement, type UseProBreakpointsReturn, type UseRequestOptionsParams, type UseRequestOptionsReturn, type UseTableFormOptions, type UseTableFormReturn, type UseTableOptions, type UseTableReturn, useFetchData, useInjectTableContext, usePagination, useProBreakpoints, useRequestOptions, useTable, useTableForm };

package/dist/index.js

@@ -1,4 +1,10 @@
-import { proTableProps } from "./props.js";
-import ProTable from "./ProTable.js";
+import { useProBreakpoints } from "./hooks/useBreakpoints.js";
+import { useRequestOptions } from "./hooks/useRequestOptions.js";
+import { useInjectTableContext } from "./context/TableContext.js";
+import { useFetchData } from "./hooks/useFetchData.js";
+import { usePagination } from "./hooks/usePagination.js";
 import { useTable } from "./hooks/useTable.js";
-export { ProTable as GProTable, proTableProps, useTable };
+import { useTableForm } from "./hooks/useTableForm.js";
+import "./hooks/index.js";
+import ForwardProTable from "./ProTable.js";
+export { ForwardProTable as GProTable, useFetchData, useInjectTableContext, usePagination, useProBreakpoints, useRequestOptions, useTable, useTableForm };