cnhis-design-vue 3.1.23-beta.9 → 3.1.24-beta.0

package/es/components/big-table/src/components/separate.vue.d.ts

@@ -19,9 +19,7 @@ declare const _default: import("vue").DefineComponent<{
             type: PropType<AnyObject>;
             required: true;
         };
-    }>> & {
-        [x: `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
-    }>>;
+    }>> & {}>>;
     separateDataMap: import("vue").Ref<WeakMap<AnyObject, {
         separateData: Record<string, string>;
         index: number;
@@ -29,7 +27,7 @@ declare const _default: import("vue").DefineComponent<{
         row: AnyObject;
     }>>;
     displayContent: import("vue").ComputedRef<string>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     col: {
         type: PropType<AnyObject>;
         required: true;

package/es/components/big-table/src/constants/index.js

@@ -1 +1,3 @@
-export { InjectionSeparateHandle } from './index2.js';
+const InjectionSeparateHandle = Symbol("InjectionSeparateHandle");
+
+export { InjectionSeparateHandle };

package/es/components/big-table/src/hooks/export.js

@@ -1 +1 @@
-export { useColumnConfigAdaptor } from './useColumnConfigAdaptor2.js';
+export { useColumnConfigAdaptor } from './useColumnConfigAdaptor.js';

package/es/components/big-table/src/hooks/index.js

@@ -1,9 +1,9 @@
-export { useAnchor } from './useAnchor2.js';
-export { comps, useEdit } from './useEdit2.js';
-export { useFormat } from './useFormat2.js';
-export { useTableParse } from './useTableParse2.js';
-export { useBatchEditing } from './useBatchEditing2.js';
-export { useNestTable } from './useNestTable2.js';
-export { useEvent } from './useEvent2.js';
+export { useAnchor } from './useAnchor.js';
+export { comps, useEdit } from './useEdit.js';
+export { useFormat } from './useFormat.js';
+export { useTableParse } from './useTableParse.js';
+export { useBatchEditing } from './useBatchEditing.js';
+export { useNestTable } from './useNestTable.js';
+export { useEvent } from './useEvent.js';
 export { useAnnotation } from './useAnnotation.js';
-export { SeparateHandle, useSeparateMap, useSeparateRow } from './useSeparateRow2.js';
+export { SeparateHandle, useSeparateMap, useSeparateRow } from './useSeparateRow.js';

package/es/components/big-table/src/hooks/useAnchor.js

@@ -1 +1,49 @@
-export { useAnchor } from './useAnchor2.js';
+import { useThrottleFn } from '@vueuse/core';
+
+const useAnchor = (props, state, emit, xGrid) => {
+  let setAnchorStatus = true;
+  function initAnchor() {
+    var _a, _b, _c;
+    if ((_a = props.anchor) == null ? void 0 : _a.length) {
+      const columns = xGrid.value.getColumns();
+      let left = 0;
+      columns.forEach((column) => {
+        const { field, minWidth, width, fixed } = column;
+        const colWidth = +(minWidth || width);
+        if (fixed == "left") ; else {
+          left += colWidth;
+          const anchorObj = props.anchor.find((v) => v.field === field);
+          anchorObj && state.anchorList.push({
+            ...anchorObj,
+            left: left - colWidth
+          });
+        }
+      });
+      state.anchorValue = ((_c = (_b = state.anchorList) == null ? void 0 : _b[0]) == null ? void 0 : _c.field) || "";
+    }
+  }
+  async function updateAnchor(field) {
+    setAnchorStatus = false;
+    const anchorObj = state.anchorList.find((v) => v.field === field);
+    await xGrid.value.scrollTo(anchorObj.left);
+    setTimeout(() => {
+      setAnchorStatus = true;
+    });
+  }
+  function setAnchorValue({ scrollLeft }) {
+    if (state.anchorList.length && setAnchorStatus) {
+      const anchorObj = state.anchorList.find((v) => scrollLeft < v.left);
+      if (anchorObj) {
+        state.anchorValue = anchorObj.field;
+      }
+    }
+  }
+  const anchorEvent = useThrottleFn(setAnchorValue, 800);
+  return {
+    initAnchor,
+    updateAnchor,
+    anchorEvent
+  };
+};
+
+export { useAnchor };

package/es/components/big-table/src/hooks/useAnnotation.js

@@ -1,6 +1,6 @@
 import { createVNode } from 'vue';
 import { isObject } from '@vue/shared';
-import Annotation from '../../../annotation-edit/index2.js';
+import Annotation from '../../../annotation-edit/index.js';
 
 function useAnnotation(props) {
   function renderAnnotation(columnConfig) {

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

@@ -1 +1,301 @@
-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/components/big-table/src/hooks/useColumnConfigAdaptor.js

@@ -1 +1,158 @@
-export { useColumnConfigAdaptor } from './useColumnConfigAdaptor2.js';
+import { cloneDeep, isString, isFunction, isArray } from 'lodash-es';
+import { isObject } from '@vue/shared';
+
+const REMOVE_PROPERTY = Symbol("remove property");
+function useColumnConfigAdaptor() {
+  function formConfigLikeAdaptor(payload) {
+    const editRules = {};
+    if (!isObject(payload))
+      return { fieldList: [], editRules };
+    const fieldList = formConfigLikeFieldListTransfer(payload.fieldList);
+    return { fieldList, editRules };
+    function formConfigLikeFieldListTransfer(fieldList2) {
+      const fixedWayEnumValueMap = /* @__PURE__ */ new Map([
+        ["NONE", 0],
+        ["LEFT", 1],
+        ["RIGHT", 2]
+      ]);
+      const multipleValueMap = /* @__PURE__ */ new Map([
+        ["0", false],
+        ["1", true]
+      ]);
+      const isEditValueMap = /* @__PURE__ */ new Map([
+        ["0", 0],
+        ["1", 1]
+      ]);
+      const htmlTypeValueMap = new Map([
+        ...["RADIO", "RADIO_BLOCK", "CHECKBOX", "CHECKBOX_BLOCK", "SELECT", "SWITCH_COMPONENT"].map((type) => [
+          type,
+          "select"
+        ]),
+        ...["DATE"].map((type) => [type, "date"]),
+        ...["INPUT"].map((type) => [type, "input"]),
+        ...["DIGITAL"].map((type) => [type, "number"])
+      ]);
+      const isNullHandler = (value, result, _fieldItem, _editRules) => {
+        if (value === "1")
+          return;
+        if (value === "0")
+          _editRules[_fieldItem.val_key] = [{ required: true, message: "\u5FC5\u586B" }];
+      };
+      const validateHandler = (value, result) => {
+        if (!isObject(value))
+          return;
+        const keyMap = {
+          maxlength: "max_length",
+          minlength: "min_length",
+          max: "max_value",
+          min: "min_value",
+          precision: "decimal_length"
+        };
+        result.componentProps = Object.assign(
+          {},
+          result.comonentProps,
+          Object.entries(keyMap).reduce((res, [k, v]) => {
+            res[k] = value[v];
+            return res;
+          }, {})
+        );
+      };
+      const dateRangeValidate = (value, result) => {
+        if (!isObject(value))
+          return;
+        result.isDateDisabled = (ts, row) => {
+          if (!isObject(row))
+            return;
+          const { startDate, endDate } = value;
+          let invalid = false;
+          if (startDate) {
+            invalid = new Date(row[startDate]).getTime() > ts;
+          }
+          if (endDate) {
+            invalid = invalid || new Date(row[endDate]).getTime() < ts;
+          }
+          return invalid;
+        };
+      };
+      const switchOptionHandler = (value, result) => {
+        if (!isObject(value))
+          return;
+        const option = { label: value.describe, ...value };
+        result.options = isArray(result.options) ? [...result.options, option] : [option];
+      };
+      const htmlTypeHandler = (value, result, fieldItem) => {
+        var _a;
+        if (!isString(value))
+          return;
+        if (value === "DATE") {
+          result.formType = isString(fieldItem.date_format) && fieldItem.date_format.startsWith("HH:mm") ? "time" : "date";
+          return;
+        }
+        result.formType = (_a = htmlTypeValueMap.get(value)) != null ? _a : value;
+      };
+      const settingMap = new Map([
+        ["multi_select_value", { property: "multiple", valueMap: multipleValueMap }],
+        ["is_null", isNullHandler],
+        ["validate", validateHandler],
+        ["dateValidate", dateRangeValidate],
+        ["date_format", "valueFormat"],
+        ...["open", "close"].map((key) => [key, switchOptionHandler]),
+        ["is_edit", { property: "isEdit", valueMap: isEditValueMap }],
+        ["html_type", htmlTypeHandler],
+        ["option", { property: "options", fieldMap: /* @__PURE__ */ new Map([["text", "label"]]) }],
+        [
+          "alias",
+          (value, result, fieldItem) => {
+            result.title = `${value}${fieldItem.suffix ? `(${fieldItem.suffix})` : ""}`;
+          }
+        ]
+      ]);
+      const fieldMap = /* @__PURE__ */ new Map([
+        ["sum", "isSum"],
+        ["show", "isShow"],
+        ["elementId", "columnName"],
+        ["columnWidth", "colWidth"],
+        ["fixedWayEnum", { property: "isFixed", valueMap: fixedWayEnumValueMap }],
+        ["setting", { fieldMap: settingMap, assign: true }]
+      ]);
+      return fieldList2.map((fieldItem) => transfer(fieldItem, editRules, fieldMap));
+      function transfer(fieldItem, _editRules, ruleMap) {
+        if (!ruleMap)
+          return cloneDeep(fieldItem);
+        const result = {};
+        Object.entries(fieldItem).forEach(([key, value]) => {
+          const rule = ruleMap.get(key);
+          if (!rule)
+            return result[key] = value;
+          if (rule === REMOVE_PROPERTY)
+            return;
+          if (isString(rule))
+            return result[rule] = value;
+          if (isFunction(rule))
+            return rule(value, result, fieldItem, _editRules);
+          if (isObject(rule)) {
+            if (rule.assign) {
+              Object.assign(result, valueTransfer(value, rule));
+            } else {
+              result[rule.property || key] = valueTransfer(value, rule);
+            }
+          }
+        });
+        return result;
+        function valueTransfer(value, rule) {
+          var _a, _b;
+          if (!isObject(rule) || isFunction(rule))
+            return value;
+          if (isArray(value))
+            return value.map((v) => valueTransfer(v, rule));
+          if (isObject(value))
+            return transfer(value, _editRules, rule.fieldMap);
+          return (_b = (_a = rule.valueMap) == null ? void 0 : _a.get(value)) != null ? _b : value;
+        }
+      }
+    }
+  }
+  return { formConfigLikeAdaptor };
+}
+
+export { useColumnConfigAdaptor };

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

@@ -255,7 +255,7 @@ export declare const comps: {
             rootSlots: {
                 type: import("vue").PropType<Record<string, import("../../../../shared/types").Func<any[], any>>>;
             };
-        }, () => any, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        }, () => any, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
             renderer: {
                 type: import("vue").PropType<string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions> | import("../../../../shared/types").Func<any[], any>>;
                 required: true;
@@ -285,9 +285,7 @@ export declare const comps: {
                     type: import("vue").PropType<import("../../../../shared/types").AnyObject>;
                     required: true;
                 };
-            }>> & {
-                [x: `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
-            }>>;
+            }>> & {}>>;
             separateDataMap: import("vue").Ref<WeakMap<import("../../../../shared/types").AnyObject, {
                 separateData: Record<string, string>;
                 index: number;
@@ -295,7 +293,7 @@ export declare const comps: {
                 row: import("../../../../shared/types").AnyObject;
             }>>;
             displayContent: import("vue").ComputedRef<string>;
-        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
             col: {
                 type: import("vue").PropType<import("../../../../shared/types").AnyObject>;
                 required: true;