vue-devui 1.6.34 → 1.6.36-alpha.0

package/types/table/src/components/header-th/use-header-th.d.ts

@@ -1,7 +1,7 @@
-import { Ref } from 'vue';
-import { Column } from '../column/column-types';
-import { UseSort, UseFilter, UseBaseRender, UseDragColumnWidth } from './header-th-types';
-export declare function useBaseRender(column: Ref<Column>): UseBaseRender;
-export declare function useSort(column: Ref<Column>): UseSort;
-export declare function useFilter(column: Ref<Column>): UseFilter;
-export declare function useDragColumnWidth(elementRef: Ref<HTMLElement>, column: Ref<Column>): UseDragColumnWidth;
+import { Ref } from 'vue';
+import { Column } from '../column/column-types';
+import { UseSort, UseFilter, UseBaseRender, UseDragColumnWidth } from './header-th-types';
+export declare function useBaseRender(column: Ref<Column>): UseBaseRender;
+export declare function useSort(column: Ref<Column>): UseSort;
+export declare function useFilter(column: Ref<Column>): UseFilter;
+export declare function useDragColumnWidth(elementRef: Ref<HTMLElement>, column: Ref<Column>): UseDragColumnWidth;

package/types/table/src/components/normal-header.d.ts

@@ -1,21 +1,11 @@
-declare const _default: import("vue").DefineComponent<{
-    classes: {
-        type: ObjectConstructor;
-        default: () => {};
-    };
-    isEmpty: {
-        type: BooleanConstructor;
-    };
-}, () => any, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-    classes: {
-        type: ObjectConstructor;
-        default: () => {};
-    };
-    isEmpty: {
-        type: BooleanConstructor;
-    };
-}>>, {
-    classes: Record<string, any>;
-    isEmpty: boolean;
-}, {}>;
-export default _default;
+declare const _default: import("vue").DefineComponent<{
+    classes: Record<string, unknown>;
+    isEmpty: boolean;
+}, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    classes: Record<string, unknown>;
+    isEmpty: boolean;
+}> & Readonly<{}>, {
+    classes: Record<string, any>;
+    isEmpty: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/table/src/components/sort/sort-types.d.ts

@@ -1,9 +1,9 @@
-import type { ExtractPropTypes, PropType } from 'vue';
-import { SortDirection } from '../column/column-types';
-export declare const sortProps: {
-    sortDirection: {
-        type: PropType<SortDirection>;
-        default: string;
-    };
-};
-export type SortProps = ExtractPropTypes<typeof sortProps>;
+import type { ExtractPropTypes, PropType } from 'vue';
+import { SortDirection } from '../column/column-types';
+export declare const sortProps: {
+    sortDirection: {
+        type: PropType<SortDirection>;
+        default: string;
+    };
+};
+export type SortProps = ExtractPropTypes<typeof sortProps>;

package/types/table/src/components/sort/sort.d.ts

@@ -1,17 +1,11 @@
-import './sort.scss';
-declare const _default: import("vue").DefineComponent<{
-    sortDirection: {
-        type: import("vue").PropType<import("../column/column-types").SortDirection>;
-        default: string;
-    };
-}, () => any, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "sort"[], "sort", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-    sortDirection: {
-        type: import("vue").PropType<import("../column/column-types").SortDirection>;
-        default: string;
-    };
-}>> & {
-    onSort?: ((...args: any[]) => any) | undefined;
-}, {
-    sortDirection: import("../column/column-types").SortDirection;
-}, {}>;
-export default _default;
+import './sort.scss';
+declare const _default: import("vue").DefineComponent<{
+    sortDirection: import("../column/column-types").SortDirection;
+}, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "sort"[], "sort", import("vue").PublicProps, Readonly<{
+    sortDirection: import("../column/column-types").SortDirection;
+}> & Readonly<{
+    onSort?: ((...args: any[]) => any) | undefined;
+}>, {
+    sortDirection: import("../column/column-types").SortDirection;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/table/src/composables/use-horizontal-scroll.d.ts

@@ -1,3 +1,3 @@
-import { ITableInstanceAndDefaultRow } from '../table-types';
-import { UseHorizontalScroll } from './use-table-types';
-export declare function useHorizontalScroll(table: ITableInstanceAndDefaultRow): UseHorizontalScroll;
+import { ITableInstanceAndDefaultRow } from '../table-types';
+import { UseHorizontalScroll } from './use-table-types';
+export declare function useHorizontalScroll(table: ITableInstanceAndDefaultRow): UseHorizontalScroll;

package/types/table/src/composables/use-sort.d.ts

@@ -1,3 +1,3 @@
-import type { Ref } from 'vue';
-import { UseSort } from './use-table-types';
-export declare function useSort<T extends Record<string, unknown>>(dataSource: Ref<T[]>, _data: Ref<T[]>): UseSort<T>;
+import type { Ref } from 'vue';
+import { UseSort } from './use-table-types';
+export declare function useSort<T extends Record<string, unknown>>(dataSource: Ref<T[]>, _data: Ref<T[]>): UseSort<T>;

package/types/table/src/composables/use-table-types.d.ts

@@ -1,10 +1,10 @@
-import type { ComponentInternalInstance } from 'vue';
-import type { SortDirection, SortMethod } from '../components/column/column-types';
-export interface UseHorizontalScroll {
-    onTableScroll: (e: Event) => void;
-}
-export interface UseSort<T> {
-    thList: ComponentInternalInstance[];
-    collectTh: (th: ComponentInternalInstance) => void;
-    sortData: (direction: SortDirection, sortMethod: SortMethod<T> | undefined) => void;
-}
+import type { ComponentInternalInstance } from 'vue';
+import type { SortDirection, SortMethod } from '../components/column/column-types';
+export interface UseHorizontalScroll {
+    onTableScroll: (e: Event) => void;
+}
+export interface UseSort<T> {
+    thList: ComponentInternalInstance[];
+    collectTh: (th: ComponentInternalInstance) => void;
+    sortData: (direction: SortDirection, sortMethod: SortMethod<T> | undefined) => void;
+}

package/types/table/src/composables/use-table.d.ts

@@ -1,8 +1,8 @@
-import type { Ref } from 'vue';
-import { Column } from '../components/column/column-types';
-import { ITable, DefaultRow, TableProps, UseTable, UseFixedColumn, UseTableLayout } from '../table-types';
-import { TableStore } from '../store/store-types';
-export declare function useTable(props: TableProps, tableWidth: Ref): UseTable;
-export declare const useFixedColumn: (column: Ref<Column>) => UseFixedColumn;
-export declare function useTableLayout(table: ITable<DefaultRow>): UseTableLayout;
-export declare function useTableWatcher(props: TableProps, store: TableStore): void;
+import type { Ref } from 'vue';
+import { Column } from '../components/column/column-types';
+import { ITable, DefaultRow, TableProps, UseTable, UseFixedColumn, UseTableLayout } from '../table-types';
+import { TableStore } from '../store/store-types';
+export declare function useTable(props: TableProps, tableWidth: Ref): UseTable;
+export declare const useFixedColumn: (column: Ref<Column>) => UseFixedColumn;
+export declare function useTableLayout(table: ITable<DefaultRow>): UseTableLayout;
+export declare function useTableWatcher(props: TableProps, store: TableStore): void;

package/types/table/src/store/index.d.ts

@@ -1,11 +1,11 @@
-import { Ref } from 'vue';
-import type { SetupContext } from 'vue';
-import type { DefaultRow, ITable } from '../table-types';
-import type { TableStore } from './store-types';
-/**
- * 创建 TableStore
- * @param dataSource 数据源
- * @param table 表对象
- * @returns TableStore
- */
-export declare function createStore<T extends Record<string, unknown>>(dataSource: Ref<T[]>, table: ITable<DefaultRow>, ctx: SetupContext): TableStore<T>;
+import { Ref } from 'vue';
+import type { SetupContext } from 'vue';
+import type { DefaultRow, ITable } from '../table-types';
+import type { TableStore } from './store-types';
+/**
+ * 创建 TableStore
+ * @param dataSource 数据源
+ * @param table 表对象
+ * @returns TableStore
+ */
+export declare function createStore<T extends Record<string, unknown>>(dataSource: Ref<T[]>, table: ITable<DefaultRow>, ctx: SetupContext): TableStore<T>;

package/types/table/src/store/store-types.d.ts

@@ -1,49 +1,49 @@
-import type { ComponentInternalInstance, Ref } from 'vue';
-import { Column, SortMethod, SortDirection } from '../components/column/column-types';
-import { DefaultRow } from '../table-types';
-export interface TableStore<T = Record<string, unknown>> {
-    states: {
-        _data: Ref<T[]>;
-        flatRows: Ref<T[]>;
-        hiddenRowKeys: Ref<string[]>;
-        rowLevelMap: Ref<Record<string, number>>;
-        _columns: Ref<Column[]>;
-        flatColumns: Ref<Column[]>;
-        _checkSet: Ref<Set<string>>;
-        _checkAll: Ref<boolean>;
-        _halfChecked: Ref<boolean>;
-        isFixedLeft: Ref<boolean>;
-        thList: ComponentInternalInstance[];
-        firstDefaultColumn: Ref<string>;
-        tableCellModeMap: Ref<Map<string, string>>;
-    };
-    insertColumn(column: Column, parent: unknown): void;
-    sortColumn(): void;
-    removeColumn(column: Column): void;
-    updateColumns(): void;
-    updateRows(): void;
-    getCheckedRows(): T[];
-    collectTh(th: ComponentInternalInstance): void;
-    sortData(direction: SortDirection, sortMethod: SortMethod<T> | undefined): void;
-    isRowChecked(row: T, index: number): boolean;
-    checkRow(toggle: boolean, row: T, index?: number): void;
-    toggleRowExpansion(row: T): void;
-    isRowExpanded(row: T): boolean;
-    setExpandRows: (rowKeys: string[]) => void;
-    toggleRowSelection: (row: T) => void;
-    updateFirstDefaultColumn: () => void;
-    setCellMode: (row: DefaultRow, rowIndex: number, fields: string | string[], cellMode: string) => void;
-    resetCellMode: () => void;
-    emitTableEvent: (eventName: string, ...params: unknown[]) => void;
-}
-export interface UseExpand {
-    isRowExpanded: (row: DefaultRow) => boolean;
-    updateExpandRows: () => void;
-    setExpandRows: (rowKeys: string[]) => void;
-    toggleRowExpansion: (row: DefaultRow, expanded?: boolean) => void;
-}
-export interface UseEditTableCell {
-    tableCellModeMap: Ref<Map<string, string>>;
-    setCellMode: (row: DefaultRow, rowIndex: number, fields: string | string[], cellMode: string) => void;
-    resetCellMode: () => void;
-}
+import type { ComponentInternalInstance, Ref } from 'vue';
+import { Column, SortMethod, SortDirection } from '../components/column/column-types';
+import { DefaultRow } from '../table-types';
+export interface TableStore<T = Record<string, unknown>> {
+    states: {
+        _data: Ref<T[]>;
+        flatRows: Ref<T[]>;
+        hiddenRowKeys: Ref<string[]>;
+        rowLevelMap: Ref<Record<string, number>>;
+        _columns: Ref<Column[]>;
+        flatColumns: Ref<Column[]>;
+        _checkSet: Ref<Set<string>>;
+        _checkAll: Ref<boolean>;
+        _halfChecked: Ref<boolean>;
+        isFixedLeft: Ref<boolean>;
+        thList: ComponentInternalInstance[];
+        firstDefaultColumn: Ref<string>;
+        tableCellModeMap: Ref<Map<string, string>>;
+    };
+    insertColumn(column: Column, parent: unknown): void;
+    sortColumn(): void;
+    removeColumn(column: Column): void;
+    updateColumns(): void;
+    updateRows(): void;
+    getCheckedRows(): T[];
+    collectTh(th: ComponentInternalInstance): void;
+    sortData(direction: SortDirection, sortMethod: SortMethod<T> | undefined): void;
+    isRowChecked(row: T, index: number): boolean;
+    checkRow(toggle: boolean, row: T, index?: number): void;
+    toggleRowExpansion(row: T): void;
+    isRowExpanded(row: T): boolean;
+    setExpandRows: (rowKeys: string[]) => void;
+    toggleRowSelection: (row: T) => void;
+    updateFirstDefaultColumn: () => void;
+    setCellMode: (row: DefaultRow, rowIndex: number, fields: string | string[], cellMode: string) => void;
+    resetCellMode: () => void;
+    emitTableEvent: (eventName: string, ...params: unknown[]) => void;
+}
+export interface UseExpand {
+    isRowExpanded: (row: DefaultRow) => boolean;
+    updateExpandRows: () => void;
+    setExpandRows: (rowKeys: string[]) => void;
+    toggleRowExpansion: (row: DefaultRow, expanded?: boolean) => void;
+}
+export interface UseEditTableCell {
+    tableCellModeMap: Ref<Map<string, string>>;
+    setCellMode: (row: DefaultRow, rowIndex: number, fields: string | string[], cellMode: string) => void;
+    resetCellMode: () => void;
+}

package/types/table/src/store/use-edit-table-cell.d.ts

@@ -1,2 +1,2 @@
-import { UseEditTableCell } from './store-types';
-export declare function useEditTableCell(): UseEditTableCell;
+import { UseEditTableCell } from './store-types';
+export declare function useEditTableCell(): UseEditTableCell;

package/types/table/src/store/use-expand.d.ts

@@ -1,4 +1,4 @@
-import type { Ref } from 'vue';
-import { DefaultRow, ITable } from '../table-types';
-import { UseExpand } from './store-types';
-export declare function useExpand(dataSource: Ref<DefaultRow[]>, table: ITable<DefaultRow>): UseExpand;
+import type { Ref } from 'vue';
+import { DefaultRow, ITable } from '../table-types';
+import { UseExpand } from './store-types';
+export declare function useExpand(dataSource: Ref<DefaultRow[]>, table: ITable<DefaultRow>): UseExpand;

package/types/table/src/table-types.d.ts

@@ -1,135 +1,135 @@
-import type { PropType, ExtractPropTypes, ComponentInternalInstance, InjectionKey, Ref, ComputedRef, CSSProperties, ToRefs } from 'vue';
-import { TableStore } from './store/store-types';
-export type TableSize = 'sm' | 'md' | 'lg';
-export type BorderType = '' | 'bordered' | 'borderless';
-export type RowKeyType = string | ((v: Record<string, unknown>, index?: number | undefined) => string);
-export type SpanMethod = (data: {
-    row: unknown;
-    column: unknown;
-    rowIndex: number;
-    columnIndex: number;
-}) => number[] | {
-    rowspan: number;
-    colspan: number;
-};
-export declare const tableProps: {
-    data: {
-        type: PropType<Record<string, unknown>[]>;
-        default: never[];
-    };
-    striped: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    scrollable: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    maxWidth: {
-        type: StringConstructor;
-    };
-    maxHeight: {
-        type: StringConstructor;
-    };
-    tableWidth: {
-        type: StringConstructor;
-    };
-    tableHeight: {
-        type: StringConstructor;
-    };
-    size: {
-        type: PropType<TableSize>;
-        validator(value: string): boolean;
-        default: string;
-    };
-    rowHoveredHighlight: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    fixHeader: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    checkable: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    tableLayout: {
-        type: PropType<"fixed" | "auto">;
-        default: string;
-        validator(v: string): boolean;
-    };
-    showLoading: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    headerBg: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    spanMethod: {
-        type: PropType<SpanMethod>;
-    };
-    borderType: {
-        type: PropType<BorderType>;
-        default: string;
-    };
-    empty: {
-        type: StringConstructor;
-        default: string;
-    };
-    showHeader: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    rowKey: {
-        type: (StringConstructor | (new (...args: any[]) => (v: Record<string, unknown>, index?: number | undefined) => string) | (() => (v: Record<string, unknown>, index?: number | undefined) => string) | ((new (...args: any[]) => (v: Record<string, unknown>, index?: number | undefined) => string) | (() => (v: Record<string, unknown>, index?: number | undefined) => string) | {
-            (): (v: Record<string, unknown>, index?: number | undefined) => string;
-            new (): any;
-            readonly prototype: any;
-        })[])[];
-        default: string;
-    };
-    defaultExpandAll: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    expandRowKeys: {
-        type: PropType<string[]>;
-    };
-    indent: {
-        type: NumberConstructor;
-        default: number;
-    };
-    lazy: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-};
-export type TableProps = ExtractPropTypes<typeof tableProps>;
-export type DefaultRow = TableProps['data'][number];
-export interface ITable<T = DefaultRow> extends ComponentInternalInstance {
-    store: TableStore<T>;
-    props: TableProps;
-    tableId: string;
-    hiddenColumns: Ref<HTMLElement | null>;
-    tableRef: Ref<HTMLElement>;
-    updateColumnWidth: () => void;
-}
-export interface TableMethods<T = Record<string, unknown>> {
-    getCheckedRows(): T[];
-}
-export declare const TABLE_TOKEN: InjectionKey<ITable>;
-export interface UseTable {
-    classes: ComputedRef<Record<string, boolean>>;
-    styles: ComputedRef<CSSProperties>;
-}
-export type UseFixedColumn = ToRefs<{
-    stickyClass: ComputedRef<Record<string, boolean>>;
-    stickyStyle: ComputedRef<CSSProperties>;
-}>;
-export interface UseTableLayout {
-    tableWidth: Ref;
-    updateColumnWidth: () => void;
-}
-export type ITableInstanceAndDefaultRow = ComponentInternalInstance & ITable<DefaultRow>;
+import type { PropType, ExtractPropTypes, ComponentInternalInstance, InjectionKey, Ref, ComputedRef, CSSProperties, ToRefs } from 'vue';
+import { TableStore } from './store/store-types';
+export type TableSize = 'sm' | 'md' | 'lg';
+export type BorderType = '' | 'bordered' | 'borderless';
+export type RowKeyType = string | ((v: Record<string, unknown>, index?: number | undefined) => string);
+export type SpanMethod = (data: {
+    row: unknown;
+    column: unknown;
+    rowIndex: number;
+    columnIndex: number;
+}) => number[] | {
+    rowspan: number;
+    colspan: number;
+};
+export declare const tableProps: {
+    data: {
+        type: PropType<Record<string, unknown>[]>;
+        default: never[];
+    };
+    striped: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    scrollable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maxWidth: {
+        type: StringConstructor;
+    };
+    maxHeight: {
+        type: StringConstructor;
+    };
+    tableWidth: {
+        type: StringConstructor;
+    };
+    tableHeight: {
+        type: StringConstructor;
+    };
+    size: {
+        type: PropType<TableSize>;
+        validator(value: string): boolean;
+        default: string;
+    };
+    rowHoveredHighlight: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    fixHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    checkable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tableLayout: {
+        type: PropType<"fixed" | "auto">;
+        default: string;
+        validator(v: string): boolean;
+    };
+    showLoading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    headerBg: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    spanMethod: {
+        type: PropType<SpanMethod>;
+    };
+    borderType: {
+        type: PropType<BorderType>;
+        default: string;
+    };
+    empty: {
+        type: StringConstructor;
+        default: string;
+    };
+    showHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    rowKey: {
+        type: (StringConstructor | (new (...args: any[]) => (v: Record<string, unknown>, index?: number | undefined) => string) | (() => (v: Record<string, unknown>, index?: number | undefined) => string) | (((new (...args: any[]) => (v: Record<string, unknown>, index?: number | undefined) => string) | (() => (v: Record<string, unknown>, index?: number | undefined) => string) | {
+            (): (v: Record<string, unknown>, index?: number | undefined) => string;
+            new (): any;
+            readonly prototype: any;
+        }) | null)[])[];
+        default: string;
+    };
+    defaultExpandAll: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    expandRowKeys: {
+        type: PropType<string[]>;
+    };
+    indent: {
+        type: NumberConstructor;
+        default: number;
+    };
+    lazy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+};
+export type TableProps = ExtractPropTypes<typeof tableProps>;
+export type DefaultRow = TableProps['data'][number];
+export interface ITable<T = DefaultRow> extends ComponentInternalInstance {
+    store: TableStore<T>;
+    props: TableProps;
+    tableId: string;
+    hiddenColumns: Ref<HTMLElement | null>;
+    tableRef: Ref<HTMLElement>;
+    updateColumnWidth: () => void;
+}
+export interface TableMethods<T = Record<string, unknown>> {
+    getCheckedRows(): T[];
+}
+export declare const TABLE_TOKEN: InjectionKey<ITable>;
+export interface UseTable {
+    classes: ComputedRef<Record<string, boolean>>;
+    styles: ComputedRef<CSSProperties>;
+}
+export type UseFixedColumn = ToRefs<{
+    stickyClass: ComputedRef<Record<string, boolean>>;
+    stickyStyle: ComputedRef<CSSProperties>;
+}>;
+export interface UseTableLayout {
+    tableWidth: Ref;
+    updateColumnWidth: () => void;
+}
+export type ITableInstanceAndDefaultRow = ComponentInternalInstance & ITable<DefaultRow>;

package/types/table/src/table.d.ts

@@ -1,3 +1,3 @@
-import './table.scss';
-declare const _default: import("vue").DefineSetupFnComponent<Record<string, any>, {}, {}, Record<string, any> & {}, import("vue").PublicProps>;
-export default _default;
+import './table.scss';
+declare const _default: import("vue").DefineSetupFnComponent<Record<string, any>, {}, {}, Record<string, any> & {}, import("vue").PublicProps>;
+export default _default;

package/types/table/src/utils.d.ts

@@ -1,9 +1,9 @@
-import { DefaultRow, ITable, RowKeyType } from './table-types';
-export declare function formatWidth(width: number | string): number | string;
-export declare function getRowIdentity(row: DefaultRow, rowKey: RowKeyType, index?: number): string;
-export declare function getRowKeysMap(data: DefaultRow[], rowKey: RowKeyType): Record<string, {
-    row: DefaultRow;
-    index: number;
-}>;
-export declare function toggleRowExpandStatus(rowsArr: DefaultRow[], row: DefaultRow, status?: boolean): boolean;
-export declare function toggleRowVisible(expand: boolean, table: ITable<DefaultRow>, key: string): void;
+import { DefaultRow, ITable, RowKeyType } from './table-types';
+export declare function formatWidth(width: number | string): number | string;
+export declare function getRowIdentity(row: DefaultRow, rowKey: RowKeyType, index?: number): string;
+export declare function getRowKeysMap(data: DefaultRow[], rowKey: RowKeyType): Record<string, {
+    row: DefaultRow;
+    index: number;
+}>;
+export declare function toggleRowExpandStatus(rowsArr: DefaultRow[], row: DefaultRow, status?: boolean): boolean;
+export declare function toggleRowVisible(expand: boolean, table: ITable<DefaultRow>, key: string): void;

package/types/tabs/__tests__/tabs.spec.d.ts

@@ -1 +1 @@
-export {};
+export {};

package/types/tabs/index.d.ts

@@ -1,12 +1,12 @@
-import type { App } from 'vue';
-import Tabs from './src/tabs';
-import Tab from './src/components/tab/tab';
-export * from './src/tabs-types';
-export { Tabs, Tab };
-declare const _default: {
-    title: string;
-    category: string;
-    status: string;
-    install(app: App): void;
-};
-export default _default;
+import type { App } from 'vue';
+import Tabs from './src/tabs';
+import Tab from './src/components/tab/tab';
+export * from './src/tabs-types';
+export { Tabs, Tab };
+declare const _default: {
+    title: string;
+    category: string;
+    status: string;
+    install(app: App): void;
+};
+export default _default;