cnhis-design-vue 3.1.5-beta.16 → 3.1.5-beta.17

package/es/packages/big-table/src/components/input-button.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,33 @@
+import { defineComponent, ref, openBlock, createBlock, unref, withCtx, createVNode, createTextVNode } from 'vue';
+import { NInput, NButton } from 'naive-ui';
+
+const _hoisted_1 = /* @__PURE__ */ createTextVNode("\u641C\u7D22");
+var script = /* @__PURE__ */ defineComponent({
+  __name: "input-button",
+  setup(__props) {
+    const content = ref("");
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(NInput), {
+        value: content.value,
+        "onUpdate:value": _cache[1] || (_cache[1] = ($event) => content.value = $event),
+        placeholder: "\u5B57\u6BB5\u641C\u7D22",
+        class: "check-seach-input"
+      }, {
+        suffix: withCtx(() => [
+          createVNode(unref(NButton), {
+            text: "",
+            onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("trigger", content.value))
+          }, {
+            default: withCtx(() => [
+              _hoisted_1
+            ]),
+            _: 1
+          })
+        ]),
+        _: 1
+      }, 8, ["value"]);
+    };
+  }
+});
+
+export { script as default };

package/es/packages/big-table/src/hooks/useBatchEditing.js

@@ -1 +1,289 @@
-export { useBatchEditing } from './useBatchEditing2.js';
+import { computed, watch } from 'vue';
+
+const useBatchEditing = (props, state, emit, xGrid) => {
+  let _batchFieldList = [];
+  const allSelectedLength = computed(() => {
+    var _a;
+    return (_a = state.checkedRows) == null ? void 0 : _a.length;
+  });
+  watch(() => props.isBatchEditing, (val) => {
+    if (!val || props.isNestTable)
+      return false;
+    if (state.isTree != 0 || !props.isMatchComponent)
+      return false;
+    if (!checkOperateCurrentTable()) {
+      resetBatchOperationRowStatus();
+      return false;
+    }
+    hideSelectCloumns();
+    handleClickBatchEditBtnByInline();
+  });
+  watch(() => props.isBatchSave, (val) => {
+    if (!val || props.isNestTable)
+      return false;
+    if (state.isTree != 0 || !props.isMatchComponent)
+      return false;
+    if (!checkOperateCurrentTable())
+      return false;
+    handleClickBatchSaveBtnByInline();
+  });
+  watch(() => props.isBatchCancel, (val) => {
+    if (!val || props.isNestTable)
+      return false;
+    if (state.isTree != 0 || !props.isMatchComponent)
+      return false;
+    if (!checkOperateCurrentTable())
+      return false;
+    handleClickBatchCancelBtnByInline();
+  });
+  watch(() => props.isBatchCancel, (val) => {
+    if (!val || props.isNestTable)
+      return false;
+    if (state.isTree != 0 || !props.isMatchComponent)
+      return false;
+    if (!checkOperateCurrentTable())
+      return false;
+    handleClickBatchCancelBtnByInline();
+  });
+  const checkOperateCurrentTable = () => {
+    var _a;
+    if (props.isNestTable)
+      return false;
+    let id = props.inlineEditCurrentOperateBtnId;
+    let find = (_a = props.btnList) == null ? void 0 : _a.find((item) => {
+      var _a2, _b;
+      return ((_b = (_a2 = item == null ? void 0 : item.settingObj) == null ? void 0 : _a2[0]) == null ? void 0 : _b.obj_id) === id;
+    });
+    return !!find;
+  };
+  const setRowStatus = (vxeTable, rowIndex, value) => {
+    if (!vxeTable)
+      return false;
+    let tableWrap = [
+      vxeTable.querySelector(".vxe-table--main-wrapper"),
+      vxeTable.querySelector(".vxe-table--fixed-left-wrapper"),
+      vxeTable.querySelector(".vxe-table--fixed-right-wrapper"),
+      vxeTable.querySelector(".vxe-table--body-wrapper")
+    ].filter((item) => item);
+    let rowWrap = [];
+    tableWrap.forEach((table) => {
+      let row = [...table.querySelectorAll(".vxe-body--row")];
+      rowWrap.push(row[rowIndex]);
+    });
+    rowWrap = rowWrap.filter((item) => item);
+    let height = value ? `${value}px` : value;
+    let lineHeight = value ? `${value - 10}px` : value;
+    rowWrap.forEach((wrap) => {
+      let rowItemWrap = [...wrap.querySelectorAll(".vxe-cell")];
+      rowItemWrap.push(...[...wrap.querySelectorAll(".vxe-body--column")]);
+      rowItemWrap.forEach((dom) => {
+        dom.style.setProperty("height", height, "important");
+        dom.style.lineHeight = lineHeight;
+        if (height) {
+          dom.style.backgroundColor = "#EFF5FF";
+          setTimeout(() => {
+            dom.title = "";
+          }, 1e3);
+        } else {
+          dom.style.backgroundColor = null;
+        }
+      });
+    });
+  };
+  const resetBatchOperationRowStatus = () => {
+    if (state.isTree != 0)
+      return false;
+    const vxeTable = xGrid.value;
+    let { tableData } = vxeTable.getTableData();
+    vxeTable.clearActived();
+    vxeTable.resetColumn();
+    tableData.forEach((row, index) => {
+      setRowStatus(vxeTable.$el, index, null);
+      row["__isInlineEditing"] = false;
+      row["__isDisableInlineEdit"] = false;
+    });
+  };
+  const hideSelectCloumns = () => {
+    var _a;
+    const vxeTable = xGrid.value;
+    let findSelectCloumns = (_a = vxeTable.getColumns()) == null ? void 0 : _a.find((item) => item.type === state.selectType);
+    findSelectCloumns && vxeTable.hideColumn(findSelectCloumns);
+  };
+  const checkListFormUnionSettingParamsList = () => {
+    var _a, _b, _c;
+    if (!((_b = (_a = props.listFormUnionSetting) == null ? void 0 : _a.paramsList) == null ? void 0 : _b.length)) {
+      window.$message.warning("\u53EF\u7F16\u8F91\u884C\u9700\u8981\u8BBE\u7F6E\u5173\u8054\u8868\u5355\u5B57\u6BB5\uFF0C\u8BBE\u7F6E\u540E\u8BF7\u91CD\u8BD5\uFF01");
+      emit("resetInlineEditAll", false);
+      emit("triggerSpinning", false);
+      return false;
+    }
+    let find = (_c = props.fieldListOriginal) == null ? void 0 : _c.find((item) => item.isEdit == 1);
+    if (!find) {
+      window.$message.warning("\u6CA1\u6709\u8BBE\u7F6E\u53EF\u7F16\u8F91\u5B57\u6BB5\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458");
+      emit("resetInlineEditAll", false);
+      emit("triggerSpinning", false);
+      return false;
+    }
+    return true;
+  };
+  const resetStoreInlineOperationStatus = () => {
+    if (state.isTree != 0)
+      return false;
+    state.isSaveForm = false;
+  };
+  const getInlineOpreateRow = () => {
+    const vxeTable = xGrid.value;
+    if (props.isInlineAdding) {
+      let { tableData } = vxeTable.getTableData();
+      return {
+        row: tableData[0],
+        rowIndex: 0
+      };
+    }
+    if (state.showButtonTop == 0) {
+      let { row: row2, index: rowIndex } = state.currentClickBtnInfo || {};
+      return {
+        row: row2,
+        rowIndex
+      };
+    }
+    let row = props.clickRowData;
+    for (var i = 0; i < props.oldtableData.length; i++) {
+      let item = props.oldtableData[i];
+      if (item[props.primaryKey] === row[props.primaryKey])
+        break;
+    }
+    return {
+      row,
+      rowIndex: i
+    };
+  };
+  const setAllRowInlineStatus = (disabled = false) => {
+    const vxeTable = xGrid.value;
+    let { tableData } = vxeTable.getTableData();
+    tableData.forEach((row) => {
+      row["__isInlineEditing"] = false;
+      row["__isDisableInlineEdit"] = disabled;
+    });
+  };
+  const recordClickBtnInfo = (row, index) => {
+    state.currentClickBtnInfo = {
+      row,
+      index
+    };
+  };
+  const resetOperationRowStatus = () => {
+    if (state.isTree != 0)
+      return false;
+    const vxeTable = xGrid.value;
+    let { row, rowIndex } = getInlineOpreateRow();
+    if (!row)
+      return false;
+    if (row == null ? void 0 : row.__isInsertRow) {
+      vxeTable.remove(row);
+    }
+    vxeTable.clearActived().then(() => {
+      row && vxeTable.revertData(row);
+      setRowStatus(vxeTable.$el, rowIndex, null);
+      vxeTable.resetColumn();
+      setAllRowInlineStatus();
+      recordClickBtnInfo();
+    });
+  };
+  const handleClickCancelBtnByInline = async () => {
+    const vxeTable = xGrid.value;
+    setRowStatus(vxeTable.$el, 0, null);
+    resetStoreInlineOperationStatus();
+    await vxeTable.reloadData(state.originFormatList);
+    resetOperationRowStatus();
+    emit("handleClickBtnByInline", {
+      type: "CANCEL"
+    });
+  };
+  const getBatchOpreateRows = () => {
+    const vxeTable = xGrid.value;
+    let arr = state.checkedRows;
+    let { tableData } = vxeTable.getTableData();
+    if (props.isEditAllRow) {
+      arr = tableData;
+    }
+    arr.forEach((item, i) => {
+      let rowIndex = i;
+      if (!props.isEditAllRow) {
+        let matchIndex = tableData.findIndex((v) => v[props.primaryKey] == item[props.primaryKey]);
+        if (matchIndex > -1) {
+          rowIndex = matchIndex;
+        }
+      }
+      setRowStatus(vxeTable.$el, rowIndex, "66");
+      item["__isInlineEditing"] = true;
+    });
+  };
+  const handleClickBatchEditBtnByInline = async () => {
+    if (!checkListFormUnionSettingParamsList()) {
+      handleClickCancelBtnByInline();
+      return false;
+    }
+    let arr = state.checkedRows;
+    const vxeTable = xGrid.value;
+    let { tableData } = vxeTable.getTableData();
+    if (props.isEditAllRow) {
+      arr = tableData;
+    }
+    await vxeTable.loadData(arr);
+    await props.resetInlineBatchEdit();
+    setAllRowInlineStatus(true);
+    getBatchOpreateRows();
+  };
+  const handleEditFormLength = () => {
+    let fieldLength = _batchFieldList.length;
+    if (!fieldLength)
+      return;
+    if (props.isInlineAdding) {
+      return fieldLength;
+    }
+    let rowLen = allSelectedLength.value;
+    const vxeTable = xGrid.value;
+    let { tableData } = vxeTable.getTableData();
+    if (props.isEditAllRow) {
+      rowLen = tableData.length;
+    }
+    if (!rowLen)
+      return;
+    return fieldLength * rowLen;
+  };
+  const handleClickBatchSaveBtnByInline = () => {
+    if (props.spinning)
+      return false;
+    emit("resetBatchEditDoneStatus");
+    let formDom = document.querySelectorAll(".js-inlineEditForm");
+    let sliceLen = handleEditFormLength();
+    formDom = [...formDom].slice(0, sliceLen);
+    formDom.forEach((item) => {
+      item.__vue__.handleSubmitForm();
+    });
+  };
+  const handleClickBatchCancelBtnByInline = async () => {
+    state.isSaveForm = false;
+    emit("resetInlineEditAll", false);
+    const vxeTable = xGrid.value;
+    await vxeTable.reloadData(state.originFormatList);
+    resetBatchOperationRowStatus();
+  };
+  return {
+    allSelectedLength,
+    checkOperateCurrentTable,
+    setRowStatus,
+    resetBatchOperationRowStatus,
+    checkListFormUnionSettingParamsList,
+    handleClickCancelBtnByInline,
+    setAllRowInlineStatus,
+    hideSelectCloumns,
+    handleEditFormLength,
+    getInlineOpreateRow,
+    resetOperationRowStatus,
+    recordClickBtnInfo
+  };
+};
+
+export { useBatchEditing };

package/es/packages/big-table/src/hooks/useEdit.d.ts

@@ -37,9 +37,9 @@ export declare const comps: {
         onFormChange?: ((...args: any[]) => any) | undefined;
     }, {
         type: string;
+        col: Record<string, any>;
         row: Record<string, any>;
         index: number | Record<string, any>;
-        col: Record<string, any>;
     }>;
     number: import("vue").DefineComponent<{
         type: {
@@ -79,9 +79,9 @@ export declare const comps: {
         onFormChange?: ((...args: any[]) => any) | undefined;
     }, {
         type: string;
+        col: Record<string, any>;
         row: Record<string, any>;
         index: number | Record<string, any>;
-        col: Record<string, any>;
     }>;
     select: import("vue").DefineComponent<{
         col: {
@@ -113,9 +113,9 @@ export declare const comps: {
         onFormChange?: ((...args: any[]) => any) | undefined;
         onSetOptions?: ((...args: any[]) => any) | undefined;
     }, {
+        col: Record<string, any>;
         row: Record<string, any>;
         index: number | Record<string, any>;
-        col: Record<string, any>;
     }>;
     date: import("vue").DefineComponent<{
         col: {
@@ -146,9 +146,9 @@ export declare const comps: {
     }>> & {
         onFormChange?: ((...args: any[]) => any) | undefined;
     }, {
+        col: Record<string, any>;
         row: Record<string, any>;
         index: number | Record<string, any>;
-        col: Record<string, any>;
     }>;
 };
 export declare const useEdit: (props: any, state: any, emit: any, xGrid: any) => {

package/es/packages/big-table/src/hooks/useEdit.js

@@ -1 +1,115 @@
-export { comps, useEdit } from './useEdit2.js';
+import EditInput from '../components/edit-form/edit-input.js';
+import EditSelect from '../components/edit-form/edit-select.js';
+import EditDate from '../components/edit-form/edit-date.js';
+
+const comps = {
+  "input": EditInput,
+  "number": EditInput,
+  "select": EditSelect,
+  "date": EditDate
+};
+const useEdit = (props, state, emit, xGrid) => {
+  const initEditTable = async () => {
+    const { isEdit, fieldList = [] } = props.columnConfig;
+    if (!isEdit)
+      return;
+    const hasSelectTable = fieldList.find((v) => v.formType === "selectTable");
+    if (!hasSelectTable)
+      return;
+    const record = {
+      initRow: true
+    };
+    props.columnConfig.fieldList.forEach((col) => {
+      if (col.columnName !== "operatorColumn") {
+        record[col.columnName] = void 0;
+      }
+    });
+    await xGrid.value.insertAt(record, -1);
+  };
+  const deleteRow = (row, col, index) => {
+    xGrid.value.remove(row);
+    emit("clickBtn", { row, column: col, index });
+  };
+  const activeMethod = ({ row, rowIndex, column, columnIndex }) => {
+    var _a;
+    const { isEdit, fieldList } = props.columnConfig;
+    if (isEdit) {
+      const isEditCol = ((_a = fieldList.find((v) => v.columnName === column.field)) == null ? void 0 : _a.isEdit) || false;
+      if (isEditCol) {
+        return true;
+      } else {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  };
+  const onClickSelectTable = async (row) => {
+    emit("clickSelectTable", { row });
+    const record = {
+      initRow: false,
+      row: JSON.parse(JSON.stringify(row))
+    };
+    props.columnConfig.fieldList.forEach((col) => {
+      if (col.columnName !== "operatorColumn") {
+        record[col.columnName] = void 0;
+        if (Object.keys(row).includes(col.columnName)) {
+          record[col.columnName] = row[col.columnName];
+        }
+      }
+    });
+    const getInsertRecords = xGrid.value.getInsertRecords();
+    await xGrid.value.insertAt(record, getInsertRecords.at(-1));
+    xGrid.value.clearActived();
+  };
+  const getLabel = (opts, value) => {
+    var _a;
+    return ((_a = opts.find((opt) => opt.value === value)) == null ? void 0 : _a.label) || "";
+  };
+  const onFormChange = ({ value, row, column, index }) => {
+    var _a, _b;
+    let oldValue = row[column.columnName];
+    if (((column == null ? void 0 : column.formType) === "input" || (column == null ? void 0 : column.formType) === "number") && ((_a = props.columnConfig) == null ? void 0 : _a.formValidate)) {
+      row[column.columnName] = (_b = props.columnConfig) == null ? void 0 : _b.formValidate({ row, column, current: value, old: row[column.columnName] });
+    } else if (column == null ? void 0 : column.formatMap) {
+      oldValue = {
+        label: row[column.formatMap.label],
+        value: row[column.formatMap.value]
+      };
+      row[column.formatMap.label] = getLabel(row[column.columnName + "_options"] || [], value);
+      row[column.formatMap.value] = value;
+    } else {
+      row[column.columnName] = value;
+    }
+    if ((column == null ? void 0 : column.formType) === "date" && !value) {
+      row[column.columnName] = void 0;
+    }
+    emit("formChange", { value, row, column, index, oldValue });
+  };
+  const getDefaultValue = (params, item) => {
+    var _a, _b, _c;
+    const value = params.row[item.columnName];
+    if (item.formType === "select") {
+      if (item.formatMap) {
+        return params.row[item.formatMap.label];
+      }
+      if (item.options) {
+        return ((_a = item.options.find((v) => v.value == value)) == null ? void 0 : _a.label) || value || "";
+      }
+      if (item.queryOptions) {
+        return ((_c = (_b = params.row[`${item.columnName}_options`]) == null ? void 0 : _b.find((v) => v.value === value)) == null ? void 0 : _c.label) || value || "";
+      }
+    }
+    return value;
+  };
+  return {
+    initEditTable,
+    activeMethod,
+    deleteRow,
+    onClickSelectTable,
+    onFormChange,
+    getDefaultValue
+  };
+};
+
+export { comps, useEdit };

package/es/packages/big-table/src/hooks/useEvent.js

@@ -1 +1,70 @@
-export { useEvent } from './useEvent2.js';
+import vexutils from '../../../../src/utils/vexutils';
+import { hideFilterWrap } from '../utils.js';
+
+const useEvent = (props, state, emit, xGrid) => {
+  function keyDown({ $event }) {
+    var _a, _b;
+    let activeRow = null;
+    let index = 0;
+    const xGridRef = xGrid.value;
+    if (xGridRef) {
+      activeRow = xGridRef.getCurrentRecord();
+      index = xGridRef.getRowIndex(activeRow);
+    }
+    let activeIndex = index || 0;
+    if (!activeRow)
+      return;
+    const { isArrow, isEnter, isChecked } = ((_a = props.columnConfig) == null ? void 0 : _a.keyboardConfig) || {};
+    function emitKeyBoard() {
+      emit("keyboard", {
+        key: $event.key,
+        index: activeIndex,
+        row: xGridRef.getCurrentRecord()
+      });
+    }
+    if (isArrow && ($event.key === "ArrowUp" || $event.key === "ArrowDown")) {
+      if ($event.key === "ArrowUp" && index > 0) {
+        activeIndex = index - 1;
+      }
+      if ($event.key === "ArrowDown" && index < ((_b = props.data) == null ? void 0 : _b.length) - 1) {
+        activeIndex = index + 1;
+      }
+      let row = xGridRef.getData(activeIndex);
+      xGridRef.setCurrentRow(row);
+      xGridRef.scrollToRow(row);
+      emitKeyBoard();
+    }
+    if (isEnter && $event.key === "Enter") {
+      emitKeyBoard();
+    }
+    if (isChecked && $event.key === " ") {
+      $event.preventDefault();
+      xGridRef.setCheckboxRow(activeRow, true);
+      emitKeyBoard();
+      xGridRef.scrollToRow(activeRow);
+    }
+  }
+  let scrollEvent = (params) => {
+    emit("scroll", params);
+  };
+  const initScroll = () => {
+    var _a;
+    const { throttle = false, throttleTime = 800, throttleOptions = {} } = ((_a = props.columnConfig) == null ? void 0 : _a.scrollConfig) || {};
+    if (throttle) {
+      scrollEvent = vexutils.throttle(scrollEvent, throttleTime, throttleOptions);
+    }
+  };
+  initScroll();
+  const scroll = (params) => {
+    if (params.isX) {
+      hideFilterWrap(state, props);
+    }
+    scrollEvent(params);
+  };
+  return {
+    keyDown,
+    scroll
+  };
+};
+
+export { useEvent };