@blueking/ai-ui-sdk 0.5.1-beta.2 → 0.5.1-beta.4

package/dist/components/render-t-table/index.script.vue.js.js

@@ -0,0 +1,437 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _object_without_properties(source, excluded) {
+    if (source == null) return {};
+    var target = _object_without_properties_loose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+import { defineComponent as _defineComponent } from 'vue';
+import { createVNode as _createVNode, renderSlot as _renderSlot, createElementVNode as _createElementVNode, resolveComponent as _resolveComponent, mergeProps as _mergeProps, withCtx as _withCtx, openBlock as _openBlock, createBlock as _createBlock } from "vue";
+import { ref } from 'vue';
+import RenderSearchEmpty from '../render-search-empty/index.vue.js';
+import { OrderMethod, TTableColumnType } from '../../types/enum.ts.js';
+export default /*@__PURE__*/ _defineComponent({
+    props: {
+        columns: {},
+        search: {},
+        pagination: {},
+        orderBy: {},
+        orderMethod: {},
+        selectedDatas: {},
+        beforeDragSort: {},
+        expandedTreeNodes: {},
+        defaultExpandedTreeNodes: {},
+        tree: {},
+        treeExpandAndFoldIcon: {},
+        onAbnormalDragSort: {},
+        onExpandedTreeNodesChange: {},
+        onTreeExpandChange: {},
+        asyncLoading: {},
+        columnController: {},
+        columnControllerVisible: {
+            type: Boolean
+        },
+        defaultColumnControllerVisible: {
+            type: Boolean
+        },
+        displayColumns: {},
+        defaultDisplayColumns: {},
+        dragSort: {},
+        dragSortOptions: {},
+        editableCellState: {},
+        editableRowKeys: {},
+        expandIcon: {
+            type: Boolean
+        },
+        expandOnRowClick: {
+            type: Boolean
+        },
+        expandedRow: {},
+        expandedRowKeys: {},
+        defaultExpandedRowKeys: {},
+        filterIcon: {},
+        filterRow: {},
+        filterValue: {},
+        defaultFilterValue: {},
+        hideSortTips: {
+            type: Boolean,
+            default: true
+        },
+        indeterminateSelectedRowKeys: {},
+        multipleSort: {
+            type: Boolean
+        },
+        reserveSelectedRowOnPaginate: {
+            type: Boolean,
+            default: true
+        },
+        rowSelectionAllowUncheck: {
+            type: Boolean
+        },
+        rowSelectionType: {},
+        selectOnRowClick: {
+            type: Boolean
+        },
+        defaultSelectedRowKeys: {},
+        showSortColumnBgColor: {
+            type: Boolean
+        },
+        defaultSort: {},
+        sortIcon: {},
+        sortOnRowDraggable: {
+            type: Boolean
+        },
+        onAsyncLoadingClick: {},
+        onCellClick: {},
+        onChange: {},
+        onColumnChange: {},
+        onColumnControllerVisibleChange: {},
+        onDataChange: {},
+        onDisplayColumnsChange: {},
+        onDragSort: {},
+        onExpandChange: {},
+        onRowEdit: {},
+        onRowValidate: {},
+        onValidate: {},
+        activeRowKeys: {},
+        defaultActiveRowKeys: {},
+        activeRowType: {},
+        allowResizeColumnWidth: {
+            type: Boolean
+        },
+        attach: {},
+        bordered: {
+            type: Boolean
+        },
+        bottomContent: {},
+        cellEmptyContent: {
+            default: '--'
+        },
+        data: {},
+        disableDataPage: {
+            type: Boolean,
+            default: true
+        },
+        disableSpaceInactiveRow: {
+            type: Boolean
+        },
+        empty: {},
+        firstFullRow: {},
+        fixedRows: {},
+        footData: {},
+        footerAffixProps: {},
+        footerAffixedBottom: {
+            type: [
+                Boolean,
+                Object
+            ]
+        },
+        footerSummary: {},
+        headerAffixProps: {},
+        headerAffixedTop: {
+            type: [
+                Boolean,
+                Object
+            ]
+        },
+        height: {},
+        horizontalScrollAffixedBottom: {
+            type: [
+                Boolean,
+                Object
+            ]
+        },
+        hover: {
+            type: Boolean,
+            default: true
+        },
+        keyboardRowHover: {
+            type: Boolean
+        },
+        lastFullRow: {},
+        lazyLoad: {
+            type: Boolean
+        },
+        loading: {
+            type: Boolean
+        },
+        loadingProps: {},
+        locale: {},
+        maxHeight: {},
+        paginationAffixedBottom: {
+            type: [
+                Boolean,
+                Object
+            ]
+        },
+        resizable: {
+            type: Boolean,
+            default: true
+        },
+        rowAttributes: {},
+        rowClassName: {},
+        rowKey: {
+            default: 'id'
+        },
+        rowspanAndColspan: {},
+        rowspanAndColspanInFooter: {},
+        scroll: {},
+        showHeader: {
+            type: Boolean,
+            default: true
+        },
+        size: {},
+        stripe: {
+            type: Boolean
+        },
+        tableContentWidth: {},
+        tableLayout: {
+            default: 'fixed'
+        },
+        topContent: {},
+        verticalAlign: {
+            default: 'middle'
+        },
+        onActiveChange: {},
+        onActiveRowAction: {},
+        onColumnResizeChange: {},
+        onRowClick: {},
+        onRowDblclick: {},
+        onRowMousedown: {},
+        onRowMouseenter: {},
+        onRowMouseleave: {},
+        onRowMouseover: {},
+        onRowMouseup: {},
+        onScroll: {},
+        onScrollX: {},
+        onScrollY: {}
+    },
+    emits: [
+        "update:search",
+        "update:selectedDatas",
+        "sort-change",
+        "page-change"
+    ],
+    setup (__props, { emit: __emit }) {
+        const props = __props;
+        const emits = __emit;
+        const columnControllerVisible = ref(false);
+        const getAttrs = ()=>{
+            // 去掉一些自己控制的属性
+            const { search, pagination, orderBy, orderMethod, columns, selectedDatas, displayColumns, columnControllerVisible } = props, rest = _object_without_properties(props, [
+                "search",
+                "pagination",
+                "orderBy",
+                "orderMethod",
+                "columns",
+                "selectedDatas",
+                "displayColumns",
+                "columnControllerVisible"
+            ]);
+            return rest;
+        };
+        const getColumns = ()=>{
+            return props.columns.map((item)=>{
+                const { sortKey, defaultHide, isOperate } = item, rest = _object_without_properties(item, [
+                    "sortKey",
+                    "defaultHide",
+                    "isOperate"
+                ]);
+                return rest;
+            });
+        };
+        const getSortKeyByColKey = (colKey)=>{
+            var _props_columns;
+            const col = (_props_columns = props.columns) === null || _props_columns === void 0 ? void 0 : _props_columns.find((item)=>item.colKey === colKey);
+            return col === null || col === void 0 ? void 0 : col.sortKey;
+        };
+        const getColKeyBySortKey = (sortKey)=>{
+            var _props_columns;
+            const col = (_props_columns = props.columns) === null || _props_columns === void 0 ? void 0 : _props_columns.find((item)=>item.sortKey === sortKey);
+            return col === null || col === void 0 ? void 0 : col.colKey;
+        };
+        const getSort = ()=>{
+            if (!props.orderBy || !props.orderMethod) {
+                return [];
+            }
+            var _getColKeyBySortKey;
+            return {
+                sortBy: (_getColKeyBySortKey = getColKeyBySortKey(props.orderBy)) !== null && _getColKeyBySortKey !== void 0 ? _getColKeyBySortKey : props.orderBy,
+                descending: props.orderMethod === OrderMethod.Desc
+            };
+        };
+        const getPagination = ()=>{
+            if (!props.pagination) {
+                return undefined;
+            }
+            return {
+                current: props.pagination.current,
+                pageSize: props.pagination.limit,
+                total: props.pagination.count,
+                selectProps: {
+                    popupProps: {
+                        overlayClassName: 't-table-pagination-select-popup'
+                    }
+                }
+            };
+        };
+        const getColumnController = ()=>{
+            const getColumnControllerFields = ()=>{
+                const isNotOperate = (item)=>!item.isOperate;
+                const isNotCheck = (item)=>![
+                        TTableColumnType.Single,
+                        TTableColumnType.Multiple
+                    ].includes(item.type);
+                return props.columns.filter((item)=>isNotOperate(item) && isNotCheck(item)).map((item)=>item.colKey);
+            };
+            return {
+                hideTriggerButton: true,
+                fields: getColumnControllerFields(),
+                dialogProps: {
+                    preventScrollThrough: true,
+                    dialogClassName: 't-table-dialog',
+                    showOverlay: true,
+                    header: '表格设置'
+                }
+            };
+        };
+        const getDefaultDisplayColumns = ()=>{
+            return props.columns.filter((item)=>!item.defaultHide).map((item)=>item.colKey);
+        };
+        const getSelectedRowKeys = ()=>{
+            var _props_selectedDatas;
+            return (_props_selectedDatas = props.selectedDatas) === null || _props_selectedDatas === void 0 ? void 0 : _props_selectedDatas.map((item)=>item[props.rowKey]);
+        };
+        const handleUpdateSearch = (search)=>{
+            emits('update:search', search);
+        };
+        const handleFilterChange = (filterValue)=>{
+            const searchVal = _object_spread({}, props.search, filterValue);
+            emits('update:search', searchVal);
+        };
+        const handlePageChange = (pageInfo)=>{
+            emits('page-change', pageInfo.current, pageInfo.pageSize);
+        };
+        const handleSortChange = (sort)=>{
+            const sortInfo = Array.isArray(sort) ? sort[0] : sort;
+            if (!(sortInfo === null || sortInfo === void 0 ? void 0 : sortInfo.sortBy)) {
+                // 升降序互换
+                emits('sort-change', props.orderBy, props.orderMethod === OrderMethod.Desc ? OrderMethod.Asc : OrderMethod.Desc);
+                return;
+            }
+            emits('sort-change', getSortKeyByColKey(sortInfo.sortBy), sortInfo.descending ? OrderMethod.Desc : OrderMethod.Asc);
+        };
+        const handleSelectChange = (selectedRowKeys, options)=>{
+            emits('update:selectedDatas', options.selectedRowData);
+        };
+        return (_ctx, _cache)=>{
+            const _component_bk_loading = _resolveComponent("bk-loading");
+            const _component_t_enhanced_table = _resolveComponent("t-enhanced-table");
+            return _openBlock(), _createBlock(_component_t_enhanced_table, _mergeProps({
+                "column-controller-visible": columnControllerVisible.value,
+                "onUpdate:columnControllerVisible": _cache[1] || (_cache[1] = ($event)=>columnControllerVisible.value = $event)
+            }, getAttrs(), {
+                columns: getColumns(),
+                pagination: getPagination(),
+                sort: getSort(),
+                "selected-row-keys": getSelectedRowKeys(),
+                "column-controller": getColumnController(),
+                "default-display-columns": getDefaultDisplayColumns(),
+                onSortChange: handleSortChange,
+                onFilterChange: handleFilterChange,
+                onSelectChange: handleSelectChange,
+                onPageChange: handlePageChange
+            }), {
+                empty: _withCtx(()=>[
+                        _createVNode(RenderSearchEmpty, {
+                            search: __props.search,
+                            scene: "part",
+                            "onUpdate:search": handleUpdateSearch
+                        }, null, 8 /* PROPS */ , [
+                            "search"
+                        ])
+                    ]),
+                expandedRow: _withCtx(({ row })=>[
+                        _renderSlot(_ctx.$slots, "expandedRow", {
+                            row: row
+                        }, undefined, true)
+                    ]),
+                sortIcon: _withCtx(()=>[
+                        ..._cache[2] || (_cache[2] = [
+                            _createElementVNode("i", {
+                                class: "ai-ui-sdk-icon ai-ui-sdk-angle-up-fill-3 g-text-light-gray"
+                            }, null, -1 /* CACHED */ )
+                        ])
+                    ]),
+                loading: _withCtx(()=>[
+                        _createVNode(_component_bk_loading, {
+                            loading: true
+                        })
+                    ]),
+                topContent: _withCtx(()=>[
+                        _createElementVNode("i", {
+                            class: "ai-ui-sdk-icon ai-ui-sdk-setting-2 t-table-setting-trigger",
+                            onClick: _cache[0] || (_cache[0] = ($event)=>columnControllerVisible.value = true)
+                        })
+                    ]),
+                _: 3 /* FORWARDED */ 
+            }, 16 /* FULL_PROPS */ , [
+                "column-controller-visible",
+                "columns",
+                "pagination",
+                "sort",
+                "selected-row-keys",
+                "column-controller",
+                "default-display-columns"
+            ]);
+        };
+    }
+});