yanzhen-design-vue
Version:
232 lines (231 loc) • 6.4 kB
JavaScript
import { ref, computed, unref, readonly } from "vue";
import { isArray, isFunction, isString } from "lodash-es";
import { useVxeTableColumnSlotRecord } from "./use-vxe-table-column-slot-record.mjs";
import { useVxeTableTagConfig } from "./use-vxe-table-config.mjs";
import { useVxeTableProps } from "./use-vxe-table-props.mjs";
import { useVxeTableVirtual } from "./use-vxe-table-virtual.mjs";
function useVxeTableRef(props) {
const tableRef = ref();
const editRows = ref([]);
const editColumns = ref([]);
const { dataSource, rowKey, ...otherCtx } = useVxeTableProps(props);
const { isVxeTable, isElTableTag } = useVxeTableTagConfig(props);
const fields = computed(() => {
var _a;
const columns = (_a = unref(tableRef)) == null ? void 0 : _a.columns;
if (isArray(columns))
return columns.reduce((prev, { property: prop, ...column }) => {
if (prop) prev.push(prop);
return prev;
}, []);
return [];
});
function getRowid(row) {
var _a;
if (unref(isVxeTable)) {
return (_a = unref(tableRef)) == null ? void 0 : _a.getRowid(row);
}
const _rowKey = unref(rowKey);
if (isFunction(_rowKey)) {
return _rowKey(row);
}
return row == null ? void 0 : row[_rowKey];
}
function getSelectionReserveRows(isFull) {
var _a;
if (unref(isElTableTag)) {
return ((_a = unref(tableRef)) == null ? void 0 : _a.getSelectionRows()) ?? [];
}
return [];
}
function getSelectionRows(isFull) {
if (unref(isElTableTag)) {
const data = unref(dataSource);
const rows = getSelectionReserveRows(isFull);
if (isArray(data)) {
return rows.filter(
(item) => data.some((value) => {
switch (true) {
case value === item:
case getRowid(value) === getRowid(item):
return true;
}
return false;
})
);
}
}
return [];
}
const $methods = {
getRowid,
getSelectionRows,
getSelectionReserveRows
};
const methods = {
loadData(data) {
return Promise.resolve();
},
reloadData(data) {
return Promise.resolve();
},
updateData() {
return Promise.resolve();
},
setRow(rows, record) {
return Promise.resolve();
},
reloadRow(rows, record) {
return Promise.resolve();
},
reloadRowExpand(row) {
return Promise.resolve();
},
reloadExpandContent(row) {
return Promise.resolve();
},
revertData() {
return Promise.resolve();
},
clearEdit() {
editRows.value = [];
editColumns.value = [];
},
setEditRow(row, fieldOrColumn) {
console.log(unref(fields));
row && editRows.value.push(row);
fieldOrColumn && editColumns.value.push(fieldOrColumn);
},
setEditCell(row, fieldOrColumn) {
console.log(unref(fields));
row && editRows.value.push(row);
fieldOrColumn && editColumns.value.push(fieldOrColumn);
},
isEditByRow(row, fieldOrColumn) {
return unref(editRows).includes(row);
},
getCheckboxRecords: getSelectionRows,
getCheckboxReserveRecords: getSelectionReserveRows,
getRadioRecord: getSelectionRows,
getRadioReserveRecord: getSelectionReserveRows
};
const _tableRef = computed(() => {
const _methods = Object.entries(methods).reduce((prev, [key, callback]) => {
prev[key] = function(...args) {
var _a;
const fun = (_a = unref(tableRef)) == null ? void 0 : _a[key];
switch (true) {
case unref(isVxeTable):
return fun(...args);
default:
return callback(...args);
}
};
return prev;
}, {});
return new Proxy(_methods, {
get(target, p, receiver) {
switch (true) {
case (isString(p) && Object.keys(methods).includes(p)):
return unref(Reflect.get(methods, p, receiver));
}
return Reflect.get(unref(tableRef) ?? {}, p, receiver);
}
});
});
return {
...otherCtx,
...$methods,
dataSource,
rowKey,
tableRef,
_tableRef,
methods
};
}
function useVxeTableMethods(props, options) {
const { isElTableTag, isATableTag, isVxeTable } = useVxeTableTagConfig(props);
const {
dataSource,
loading,
vxeTableProps,
elTableProps,
aTableProps,
tableRef,
_tableRef,
methods: $methods,
getSelectionRows,
getSelectionReserveRows
} = useVxeTableRef(props);
const virtualRef = useVxeTableVirtual(_tableRef);
const columnSlotRecordRef = useVxeTableColumnSlotRecord(_tableRef);
const { isHiddenRecord } = useVxeTableColumnSlotRecord(_tableRef);
function isHiddenByRow(record, name) {
const hidden = isHiddenRecord(record, name);
if (hidden !== void 0) return hidden;
return false;
}
function isVirtualHiddenByRow(record, name) {
const hidden = isHiddenRecord(record, name);
if (hidden !== void 0) return hidden;
return unref(virtualRef).isVirtualHidden(record, name);
}
function hiddenCellClassName(record) {
const hidden = isHiddenByRow(record);
return hidden ? "is-hidden" : void 0;
}
const newRef = {
data: dataSource,
getSelectionRows,
getSelectionReserveRows,
isHiddenByRow,
isVirtualHiddenByRow,
getTableRef,
virtualNodeRect: unref(virtualRef).virtualNodeRect,
cellNodeRect: unref(columnSlotRecordRef).cellNodeRect
};
const $table = {
$table: tableRef,
$methods,
...unref(_tableRef),
...newRef
};
function getTableRef() {
switch (true) {
case unref(isVxeTable):
return unref(tableRef);
default:
return readonly($table);
}
}
const tableProxy = new Proxy($table, {
get(target, p, receiver) {
switch (true) {
case (isString(p) && Object.keys($table).includes(p)):
return unref(Reflect.get(target, p, receiver));
}
return Reflect.get(unref(tableRef) ?? {}, p, receiver);
}
});
const tableExpose = readonly(tableProxy);
return {
...$table,
tableRef,
_tableRef,
elTableProps,
aTableProps,
vxeTableProps,
isElTableTag,
isATableTag,
loading,
dataSource,
virtualRef,
columnSlotRecordRef,
hiddenCellClassName,
expose: tableExpose
};
}
export {
useVxeTableMethods,
useVxeTableRef
};