@fangzhongya/fang-ui 0.0.29 → 0.0.30

package/dist/components/tablesvp/index.d.ts

@@ -0,0 +1,480 @@
+import { CreateComponentPublicInstanceWithMixins, ExtractPropTypes, Component, ComponentOptionsMixin, PublicProps, GlobalComponents, GlobalDirectives, ComponentInternalInstance, VNodeProps, AllowedComponentProps, ComponentCustomProps, Slot, ComponentPublicInstance, ComponentOptionsBase, ComponentProvideOptions, DebuggerEvent, nextTick, WatchOptions, WatchStopHandle, ShallowUnwrapRef, ComponentCustomProperties, Plugin } from 'vue';
+import { DefaultSort } from '../tablesv/src/data';
+import { OnCleanup } from '@vue/reactivity';
+declare const Tablesvp: {
+    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly< ExtractPropTypes<{
+        configs: {
+            type: () => Config;
+        };
+        config: {
+            type: () => TableConfig;
+            default(): {};
+        };
+        list: {
+            type: {
+                (arrayLength: number): ListObj[];
+                (...items: ListObj[]): ListObj[];
+                new (arrayLength: number): ListObj[];
+                new (...items: ListObj[]): ListObj[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+            default(): never[];
+        };
+        load: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        options: {
+            type: ObjectConstructor;
+            default(): {};
+        };
+        compons: {
+            type: () => {
+                [key: string]: Component;
+            };
+            default(): {};
+        };
+        value: {
+            type: () => ObjAny;
+        };
+        ajax: {
+            type: (FunctionConstructor | StringConstructor)[];
+        };
+        param: {
+            type: ObjectConstructor;
+            default(): {};
+        };
+        ajaxConfig: {
+            type: ObjectConstructor;
+        };
+        onRequestAfter: {
+            type: FunctionConstructor;
+        };
+        onRequestBefore: {
+            type: FunctionConstructor;
+        };
+    }>> & Readonly<{}>, {
+        getSelection: typeof getSelection;
+        initData: (callback?: () => void) => void;
+        getList: (p?: ObjAny, callback?: (d?: ObjAny) => void) => void;
+        empty: () => void;
+    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
+        config: TableConfig;
+        param: Record<string, any>;
+        list: ListObj[];
+        options: Record<string, any>;
+        load: boolean;
+        compons: {
+            [key: string]: Component;
+        };
+    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {
+        refTable: ({
+            $: ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                size: string;
+                value: ObjAny[];
+                list: ListObj[];
+                loading: boolean;
+                options: Record<string, any>;
+                height: string | number;
+                compons: {
+                    [key: string]: Component;
+                };
+                defaultSort: DefaultSort;
+                adaptive: boolean;
+            }> & Omit<{
+                readonly size: string;
+                readonly value: ObjAny[];
+                readonly list: ListObj[];
+                readonly loading: boolean;
+                readonly options: Record<string, any>;
+                readonly height: string | number;
+                readonly compons: {
+                    [key: string]: Component;
+                };
+                readonly defaultSort: DefaultSort;
+                readonly adaptive: boolean;
+                readonly lineHeight?: string | number | undefined;
+            } & VNodeProps & AllowedComponentProps & ComponentCustomProps, "size" | "value" | "list" | "loading" | "options" | "height" | "compons" | "defaultSort" | "adaptive">;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                tableRef: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: Slot<any> | undefined;
+            }>;
+            $root: ComponentPublicInstance | null;
+            $parent: ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: HTMLDivElement;
+            $options: ComponentOptionsBase<Readonly< ExtractPropTypes<{
+                defaultSort: {
+                    type: () => DefaultSort;
+                    default(): {};
+                };
+                height: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default(): string;
+                };
+                loading: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                adaptive: BooleanConstructor;
+                list: {
+                    type: {
+                        (arrayLength: number): ListObj[];
+                        (...items: ListObj[]): ListObj[];
+                        new (arrayLength: number): ListObj[];
+                        new (...items: ListObj[]): ListObj[];
+                        isArray(arg: any): arg is any[];
+                        readonly prototype: any[];
+                        from<T>(arrayLike: ArrayLike<T>): T[];
+                        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        of<T>(...items: T[]): T[];
+                        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                        readonly [Symbol.species]: ArrayConstructor;
+                    };
+                    default(): never[];
+                };
+                value: {
+                    type: {
+                        (arrayLength: number): ObjAny[];
+                        (...items: ObjAny[]): ObjAny[];
+                        new (arrayLength: number): ObjAny[];
+                        new (...items: ObjAny[]): ObjAny[];
+                        isArray(arg: any): arg is any[];
+                        readonly prototype: any[];
+                        from<T>(arrayLike: ArrayLike<T>): T[];
+                        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        of<T>(...items: T[]): T[];
+                        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                        readonly [Symbol.species]: ArrayConstructor;
+                    };
+                    default(): never[];
+                };
+                lineHeight: {
+                    type: (NumberConstructor | StringConstructor)[];
+                };
+                size: {
+                    type: StringConstructor;
+                    default(): string;
+                };
+                options: {
+                    type: ObjectConstructor;
+                    default(): {};
+                };
+                compons: {
+                    type: () => {
+                        [key: string]: Component;
+                    };
+                    default(): {};
+                };
+            }>> & Readonly<{}>, {
+                clearSelection: () => void;
+                clearRadioRow: () => void;
+            }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
+                size: string;
+                value: ObjAny[];
+                list: ListObj[];
+                loading: boolean;
+                options: Record<string, any>;
+                height: string | number;
+                compons: {
+                    [key: string]: Component;
+                };
+                defaultSort: DefaultSort;
+                adaptive: boolean;
+            }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+        } & Readonly<{
+            size: string;
+            value: ObjAny[];
+            list: ListObj[];
+            loading: boolean;
+            options: Record<string, any>;
+            height: string | number;
+            compons: {
+                [key: string]: Component;
+            };
+            defaultSort: DefaultSort;
+            adaptive: boolean;
+        }> & Omit<Readonly< ExtractPropTypes<{
+            defaultSort: {
+                type: () => DefaultSort;
+                default(): {};
+            };
+            height: {
+                type: (NumberConstructor | StringConstructor)[];
+                default(): string;
+            };
+            loading: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            adaptive: BooleanConstructor;
+            list: {
+                type: {
+                    (arrayLength: number): ListObj[];
+                    (...items: ListObj[]): ListObj[];
+                    new (arrayLength: number): ListObj[];
+                    new (...items: ListObj[]): ListObj[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                    fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                default(): never[];
+            };
+            value: {
+                type: {
+                    (arrayLength: number): ObjAny[];
+                    (...items: ObjAny[]): ObjAny[];
+                    new (arrayLength: number): ObjAny[];
+                    new (...items: ObjAny[]): ObjAny[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                    fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                default(): never[];
+            };
+            lineHeight: {
+                type: (NumberConstructor | StringConstructor)[];
+            };
+            size: {
+                type: StringConstructor;
+                default(): string;
+            };
+            options: {
+                type: ObjectConstructor;
+                default(): {};
+            };
+            compons: {
+                type: () => {
+                    [key: string]: Component;
+                };
+                default(): {};
+            };
+        }>> & Readonly<{}>, "clearSelection" | ("size" | "value" | "list" | "loading" | "options" | "height" | "compons" | "defaultSort" | "adaptive") | "clearRadioRow"> & ShallowUnwrapRef<{
+            clearSelection: () => void;
+            clearRadioRow: () => void;
+        }> & {} & ComponentCustomProperties & {} & {
+            $slots: Partial<Record<string, (_: any) => any>> & {
+                'no-data'?(_: {}): any;
+            };
+        }) | null;
+    }, HTMLDivElement, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly< ExtractPropTypes<{
+        configs: {
+            type: () => Config;
+        };
+        config: {
+            type: () => TableConfig;
+            default(): {};
+        };
+        list: {
+            type: {
+                (arrayLength: number): ListObj[];
+                (...items: ListObj[]): ListObj[];
+                new (arrayLength: number): ListObj[];
+                new (...items: ListObj[]): ListObj[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+            default(): never[];
+        };
+        load: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        options: {
+            type: ObjectConstructor;
+            default(): {};
+        };
+        compons: {
+            type: () => {
+                [key: string]: Component;
+            };
+            default(): {};
+        };
+        value: {
+            type: () => ObjAny;
+        };
+        ajax: {
+            type: (FunctionConstructor | StringConstructor)[];
+        };
+        param: {
+            type: ObjectConstructor;
+            default(): {};
+        };
+        ajaxConfig: {
+            type: ObjectConstructor;
+        };
+        onRequestAfter: {
+            type: FunctionConstructor;
+        };
+        onRequestBefore: {
+            type: FunctionConstructor;
+        };
+    }>> & Readonly<{}>, {
+        getSelection: typeof getSelection;
+        initData: (callback?: () => void) => void;
+        getList: (p?: ObjAny, callback?: (d?: ObjAny) => void) => void;
+        empty: () => void;
+    }, {}, {}, {}, {
+        config: TableConfig;
+        param: Record<string, any>;
+        list: ListObj[];
+        options: Record<string, any>;
+        load: boolean;
+        compons: {
+            [key: string]: Component;
+        };
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & ComponentOptionsBase<Readonly< ExtractPropTypes<{
+    configs: {
+        type: () => Config;
+    };
+    config: {
+        type: () => TableConfig;
+        default(): {};
+    };
+    list: {
+        type: {
+            (arrayLength: number): ListObj[];
+            (...items: ListObj[]): ListObj[];
+            new (arrayLength: number): ListObj[];
+            new (...items: ListObj[]): ListObj[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default(): never[];
+    };
+    load: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    options: {
+        type: ObjectConstructor;
+        default(): {};
+    };
+    compons: {
+        type: () => {
+            [key: string]: Component;
+        };
+        default(): {};
+    };
+    value: {
+        type: () => ObjAny;
+    };
+    ajax: {
+        type: (FunctionConstructor | StringConstructor)[];
+    };
+    param: {
+        type: ObjectConstructor;
+        default(): {};
+    };
+    ajaxConfig: {
+        type: ObjectConstructor;
+    };
+    onRequestAfter: {
+        type: FunctionConstructor;
+    };
+    onRequestBefore: {
+        type: FunctionConstructor;
+    };
+}>> & Readonly<{}>, {
+    getSelection: typeof getSelection;
+    initData: (callback?: () => void) => void;
+    getList: (p?: ObjAny, callback?: (d?: ObjAny) => void) => void;
+    empty: () => void;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
+    config: TableConfig;
+    param: Record<string, any>;
+    list: ListObj[];
+    options: Record<string, any>;
+    load: boolean;
+    compons: {
+        [key: string]: Component;
+    };
+}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+    $slots: Partial<Record<string, (_: any) => any>>;
+}) & Plugin;
+export { Tablesvp, Tablesvp as default };

package/dist/components/tablesvp/index.js

@@ -0,0 +1,8 @@
+/* empty css                 */
+import { withInstall } from "../../utils/vues/withInstall.js";
+import _sfc_main from "./src/index.js";
+const Tablesvp = withInstall(_sfc_main, "Tablesvp");
+export {
+  Tablesvp,
+  Tablesvp as default
+};

package/dist/components/tablesvp/index.scss

@@ -0,0 +1,33 @@
+@use '../css/common.scss' as *;
+@use '../tablesv/index.scss' as *;
+@use '../paging/index.scss' as *;
+$tablesvp: 'tablesvp';
+@include b($tablesvp) {
+	width: 100%;
+	height: var(#{vdm('height', $tablesvp)});
+	// flex: 1;
+	display: flex;
+	flex-direction: column;
+
+	&-main {
+		display: flex;
+		flex-direction: column;
+		flex: 1;
+		width: 100%;
+		&.is-radio {
+			.#{e()}table__header {
+				.#{e()}table-column--selection {
+					.#{e()}checkbox {
+						display: none;
+					}
+				}
+			}
+		}
+	}
+	&-paginat {
+		overflow: hidden;
+		.#{e()}pagination {
+			justify-content: flex-end;
+		}
+	}
+}

package/dist/components/tablesvp/src/data.d.ts

@@ -0,0 +1,14 @@
+import { ExtractPublicPropTypes } from 'vue';
+/**
+ * @title {h2} TablesPagin 输入框
+ * @text 目前完全继承 element-plus 中 el-tables-pagin
+ */
+export declare const dataProps: {};
+export type DataProps = ExtractPublicPropTypes<typeof dataProps>;
+export declare const dataEmits: never[];
+export type DataEmits = typeof dataEmits;
+export declare const dataSlot: {};
+/**
+ * @expose refEl 获取当前组件在element-plus中暴露的方法
+ */
+export declare const dataExpose: {};

package/dist/components/tablesvp/src/index.cjs

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const index$1 = require("../../tablesv/index.cjs");
+const index$2 = require("../../paging/index.cjs");
+const pagin = require("../../tables/common/pagin.cjs");
+const index = require("../../../hooks/cssname/index.cjs");
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  props: pagin.dataProps,
+  emits: pagin.dataEmit,
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const cs = index.useCssName("tablesvp");
+    const slots = vue.useSlots();
+    const props = __props;
+    const emit = __emit;
+    const refTable = vue.ref();
+    const {
+      height,
+      getSelection,
+      initData,
+      getData,
+      empty,
+      loading,
+      tableList,
+      tableConfig,
+      onRadioChange,
+      onSortChange,
+      onListEvents,
+      onChange,
+      pagconfig,
+      formEvent,
+      onSizeChange,
+      onCurrentChange,
+      paginat,
+      data
+    } = pagin.useInit(props, emit, refTable);
+    __expose({
+      getSelection,
+      initData,
+      getList: getData,
+      empty
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass(vue.unref(cs).z()),
+        style: vue.normalizeStyle(vue.unref(cs).vdo({ height: vue.unref(height) }))
+      }, [
+        vue.createVNode(vue.unref(index$1.Tablesv), vue.mergeProps(vue.unref(tableConfig).config, vue.toHandlers(vue.unref(formEvent)), {
+          height: vue.unref(height) == "auto" ? "auto" : "100%",
+          ref_key: "refTable",
+          ref: refTable,
+          class: [vue.unref(cs).z("main")],
+          size: vue.unref(tableConfig).config?.size,
+          value: vue.unref(data).list,
+          list: vue.unref(tableList),
+          paginat: vue.unref(paginat),
+          loading: vue.unref(loading),
+          options: props.options,
+          compons: props.compons,
+          onSortChange: vue.unref(onSortChange),
+          onRadioChange: vue.unref(onRadioChange),
+          onSelectionChange: vue.unref(onChange),
+          onListEvents: vue.unref(onListEvents)
+        }), vue.createSlots({ _: 2 }, [
+          vue.renderList(Object.keys(vue.unref(slots)), (k, i) => {
+            return {
+              name: k,
+              fn: vue.withCtx((scope) => [
+                vue.renderSlot(_ctx.$slots, k, vue.normalizeProps(vue.guardReactiveProps(scope)))
+              ])
+            };
+          })
+        ]), 1040, ["height", "class", "size", "value", "list", "paginat", "loading", "options", "compons", "onSortChange", "onRadioChange", "onSelectionChange", "onListEvents"]),
+        vue.unref(tableConfig).paginat?.is ? (vue.openBlock(), vue.createBlock(vue.unref(index$2.Paging), vue.mergeProps({ key: 0 }, vue.unref(pagconfig), {
+          class: vue.unref(cs).z("paginat"),
+          paginat: vue.unref(paginat),
+          total: vue.unref(data).total,
+          onSizeChange: vue.unref(onSizeChange),
+          onCurrentChange: vue.unref(onCurrentChange)
+        }), null, 16, ["class", "paginat", "total", "onSizeChange", "onCurrentChange"])) : vue.createCommentVNode("", true)
+      ], 6);
+    };
+  }
+});
+exports.default = _sfc_main;