3h1-ui 3.0.0-next.24 → 3.0.0-next.241

package/es/ui/src/ShyTable/src/hooks/useColumns.d.ts

@@ -0,0 +1,14 @@
+import type { ShyColumn, ShyTableProps, CellFormat, GetColumnsParams, TableActionType } from '../types/table';
+import type { PaginationProps } from '../types/pagination';
+import type { ComputedRef } from 'vue';
+import { Ref } from 'vue';
+export declare const useColumns: (propsRef: ComputedRef<ShyTableProps>, getPaginationRef: ComputedRef<boolean | PaginationProps>, tableAction: ComputedRef<TableActionType>, wrapRef: Ref<ComponentRef>) => {
+    getColumnsRef: ComputedRef<ShyColumn[]>;
+    getCacheColumns: () => ShyColumn[];
+    getColumns: (opt?: GetColumnsParams) => ShyColumn[];
+    setColumns: (columnList: Partial<ShyColumn>[] | (string | string[])[]) => void;
+    getViewColumns: ComputedRef<never[]>;
+    setCacheColumnsByField: (dataIndex: string | undefined, value: Partial<ShyColumn>) => void;
+    getColumnsSummary: ComputedRef<never[]>;
+};
+export declare const formatCell: (text: string, format: CellFormat, record: Recordable, index: number, tableAction: TableActionType) => any;

package/es/ui/src/ShyTable/src/hooks/useCustomRow.d.ts

@@ -0,0 +1,19 @@
+import type { ComputedRef } from 'vue';
+import type { ShyTableProps } from '../types/table';
+interface Options {
+    setSelectedRowKeys: (keys: string[]) => void;
+    getSelectRowKeys: () => string[];
+    clearSelectedRowKeys: () => void;
+    emit: EmitType;
+    getAutoCreateKey: ComputedRef<boolean | undefined>;
+}
+export declare function useCustomRow(propsRef: ComputedRef<ShyTableProps>, { setSelectedRowKeys, getSelectRowKeys, getAutoCreateKey, clearSelectedRowKeys, emit }: Options): {
+    customRow: (record: Recordable, index: number) => {
+        onClick: (e: Event) => void;
+        onDblclick: (event: Event) => void;
+        onContextmenu: (event: Event) => void;
+        onMouseenter: (event: Event) => void;
+        onMouseleave: (event: Event) => void;
+    };
+};
+export {};

package/es/ui/src/ShyTable/src/hooks/useDataSource.d.ts

@@ -0,0 +1,29 @@
+import type { ShyTableProps, FetchParams, SorterResult } from '../types/table';
+import type { PaginationProps } from '../types/pagination';
+import { ComputedRef, Ref } from 'vue';
+interface ActionType {
+    getPaginationInfo: ComputedRef<boolean | PaginationProps>;
+    setPagination: (info: Partial<PaginationProps>) => void;
+    setLoading: (loading: boolean) => void;
+    getFieldsValue: () => Recordable;
+    clearSelectedRowKeys: () => void;
+    tableData: Ref<Recordable[]>;
+}
+export declare function useDataSource(propsRef: ComputedRef<ShyTableProps>, { getPaginationInfo, setPagination, setLoading, getFieldsValue, clearSelectedRowKeys, tableData }: ActionType, emit: EmitType): {
+    getDataSourceRef: ComputedRef<Recordable<any>[]>;
+    getDataSource: () => Recordable[];
+    getRawDataSource: () => Recordable;
+    getRowKey: ComputedRef<string | ((record: Recordable<any>) => string)>;
+    setTableData: (values: Recordable[]) => void;
+    getAutoCreateKey: ComputedRef<boolean>;
+    fetch: (opt?: FetchParams) => any;
+    reload: (opt?: FetchParams) => Promise<any>;
+    updateTableData: (index: number, key: string, value: any) => Promise<Recordable<any>>;
+    updateTableDataRecord: (rowKey: string | number, record: Recordable) => Recordable | undefined;
+    deleteTableDataRecord: (rowKey: string | number | string[] | number[]) => void;
+    insertTableDataRecord: (record: Recordable, index: number) => Recordable | undefined;
+    findTableDataRecord: (rowKey: string | number) => any;
+    handleTableChange: (pagination: PaginationProps, filters: Partial<Recordable<string[]>>, sorter: SorterResult, extra: any) => void;
+    summaryTotalData: ComputedRef<{}>;
+};
+export {};

package/es/ui/src/ShyTable/src/hooks/useLoading.d.ts

@@ -0,0 +1,6 @@
+import { ComputedRef } from 'vue';
+import type { ShyTableProps } from '../types/table';
+export declare function useLoading(props: ComputedRef<ShyTableProps>): {
+    getLoading: ComputedRef<boolean>;
+    setLoading: (loading: boolean) => void;
+};

package/es/ui/src/ShyTable/src/hooks/usePagination.d.ts

@@ -0,0 +1,10 @@
+import type { PaginationProps } from '../types/pagination';
+import type { ShyTableProps } from '../types/table';
+import { ComputedRef } from 'vue';
+export declare function usePagination(refProps: ComputedRef<ShyTableProps>): {
+    getPagination: () => PaginationProps;
+    getPaginationInfo: ComputedRef<PaginationProps>;
+    setShowPagination: (flag: boolean) => Promise<void>;
+    getShowPagination: () => boolean;
+    setPagination: (info: Partial<PaginationProps>) => void;
+};

package/es/ui/src/ShyTable/src/hooks/useRowSelection.d.ts

@@ -0,0 +1,12 @@
+import type { ShyTableProps, TableRowSelection } from '../types/table';
+import { ComputedRef, Ref } from 'vue';
+export declare function useRowSelection(propsRef: ComputedRef<ShyTableProps>, tableData: Ref<Recordable[]>, emit: EmitType): {
+    getRowSelection: () => TableRowSelection<any>;
+    getRowSelectionRef: ComputedRef<TableRowSelection<any>>;
+    getSelectRows: <T = Recordable<any>>() => T[];
+    getSelectRowKeys: () => string[];
+    setSelectedRowKeys: (rowKeys: string[]) => void;
+    clearSelectedRowKeys: () => void;
+    deleteSelectRowByKey: (key: string) => void;
+    setSelectedRows: (rows: Recordable[]) => void;
+};

package/es/ui/src/ShyTable/src/hooks/useScrollTo.d.ts

@@ -0,0 +1,4 @@
+import type { ComputedRef, Ref } from 'vue';
+export declare function useTableScrollTo(tableElRef: Ref<ComponentRef>, getDataSourceRef: ComputedRef<Recordable[]>): {
+    scrollTo: (pos: string) => void;
+};

package/es/ui/src/ShyTable/src/hooks/useShyTable.d.ts

@@ -0,0 +1,16 @@
+import type { ShyTableProps, TableActionType } from '../types/table';
+import type { FormActionType } from '../../../ShyForm';
+import type { ComputedRef, Ref } from 'vue';
+type DynamicProps<T> = {
+    [P in keyof T]: Ref<T[P]> | T[P] | ComputedRef<T[P]>;
+};
+type Props = Partial<DynamicProps<ShyTableProps>>;
+type UseTableMethod = TableActionType & {
+    getForm: () => FormActionType;
+    getAdvancedForm: () => FormActionType;
+};
+export declare function useShyTable(tableProps?: Props): [
+    (instance: TableActionType, formInstance: UseTableMethod, advancedInstance: UseTableMethod) => void,
+    UseTableMethod
+];
+export {};

package/es/ui/src/ShyTable/src/hooks/useShyTableContext.d.ts

@@ -0,0 +1,16 @@
+import type { Ref } from 'vue';
+import type { ShyTableProps, TableActionType } from '../types/table';
+import { ComputedRef } from 'vue';
+import { FormActionType, RegisterFormFn } from '../../../ShyForm';
+export type Instance = TableActionType & {
+    wrapRef: Ref<Nullable<HTMLElement>>;
+    getBindValues: ComputedRef<Recordable>;
+    registerAdvanced: RegisterFormFn;
+    advanceActions: FormActionType;
+};
+type RetInstance = Omit<Instance, 'getBindValues'> & {
+    getBindValues: ComputedRef<ShyTableProps>;
+};
+export declare function createTableContext(instance: Instance): void;
+export declare function useTableContext(): RetInstance;
+export {};

package/es/ui/src/ShyTable/src/hooks/useShyTableForm.d.ts

@@ -0,0 +1,9 @@
+import type { ComputedRef, Slots } from 'vue';
+import type { ShyTableProps, FetchParams } from '../types/table';
+import type { FormProps } from '../../../ShyForm';
+export declare function useTableForm(propsRef: ComputedRef<ShyTableProps>, slots: Slots, fetch: (opt?: FetchParams | undefined) => Promise<Recordable<any>[] | undefined>, getLoading: ComputedRef<boolean | undefined>): {
+    getFormProps: ComputedRef<Partial<FormProps>>;
+    replaceFormSlotKey: (key: string) => string;
+    getFormSlotKeys: ComputedRef<string[]>;
+    handleSearchInfoChange: (info: Recordable) => void;
+};

package/es/ui/src/ShyTable/src/hooks/useTableExpand.d.ts

@@ -0,0 +1,14 @@
+import type { ComputedRef, Ref } from 'vue';
+import type { ShyTableProps } from '../types/table';
+export declare function useTableExpand(propsRef: ComputedRef<ShyTableProps>, tableData: Ref<Recordable[]>, emit: EmitType): {
+    getExpandOption: ComputedRef<{
+        expandedRowKeys?: undefined;
+        onExpandedRowsChange?: undefined;
+    } | {
+        expandedRowKeys: string[];
+        onExpandedRowsChange: (keys: string[]) => void;
+    }>;
+    expandAll: () => void;
+    expandRows: (keys: string[]) => void;
+    collapseAll: () => void;
+};

package/es/ui/src/ShyTable/src/hooks/useTableHeader.d.ts

@@ -0,0 +1,5 @@
+import type { ComputedRef, Slots } from 'vue';
+import type { ShyTableProps, InnerHandlers } from '../types/table';
+export declare const useTableHeader: (propsRef: ComputedRef<ShyTableProps>, slots: Slots, handlers: InnerHandlers) => {
+    getHeaderProps: ComputedRef<Recordable<any>>;
+};

package/es/ui/src/ShyTable/src/hooks/useTableScroll.d.ts

@@ -0,0 +1,11 @@
+import type { ShyTableProps, TableRowSelection, ShyColumn } from '../types/table';
+import { Ref, ComputedRef } from 'vue';
+export declare function useTableScroll(propsRef: ComputedRef<ShyTableProps>, tableElRef: Ref<ComponentRef>, columnsRef: ComputedRef<ShyColumn[]>, rowSelectionRef: ComputedRef<TableRowSelection | null>, getDataSourceRef: ComputedRef<Recordable[]>, wrapRef: Ref<HTMLElement>): {
+    getScrollRef: ComputedRef<{
+        x: string | number | true;
+        y: number;
+        scrollToFirstRowOnChange: boolean;
+    }>;
+    redoHeight: () => void;
+    showAll: () => void;
+};

package/es/ui/src/ShyTable/src/hooks/useTableStyle.d.ts

@@ -0,0 +1,5 @@
+import type { ComputedRef } from 'vue';
+import type { ShyTableProps, TableCustomRecord } from '../types/table';
+export declare function useTableStyle(propsRef: ComputedRef<ShyTableProps>, prefixCls: string): {
+    getRowClassName: (record: TableCustomRecord, index: number) => string;
+};