cnhis-design-vue 3.1.14-beta.11.1 → 3.1.14-beta.13

package/es/packages/form-table/src/FormTable.js

@@ -1,4 +1,476 @@
-import script from './FormTable.vue_vue_type_script_setup_true_lang.js';
-export { default } from './FormTable.vue_vue_type_script_setup_true_lang.js';
+import { defineComponent, ref, computed, h, watch, onMounted, openBlock, createElementBlock, normalizeClass, normalizeStyle, unref, createVNode, withCtx, createCommentVNode } from 'vue';
+import { useMessage } from 'naive-ui';
+import { useComponents } from '../../../packages/form-table/src/components';
+import '../../../packages/form-table/src/configs';
+import { useValidate } from '../../../packages/form-table/src/hooks';
+import CGrid from '../../../packages/grid';
+import vexutils from '../../../src/utils/vexutils';
+import _export_sfc from '../../../_virtual/plugin-vue_export-helper.js';
 
-script.__file = "packages/form-table/src/FormTable.vue";
+const _hoisted_1 = { key: 0 };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "FormTable",
+  props: {
+    data: Array,
+    columnConfig: Object,
+    emptyItems: {
+      type: Object,
+      default: () => {
+        return {
+          noDataImg: "nodata",
+          noDataTip: ""
+        };
+      }
+    },
+    isOnlyDisplay: Boolean,
+    userInfo: {
+      type: Object,
+      default: () => ({})
+    },
+    styleSetting: {
+      type: Object,
+      default: () => ({})
+    },
+    defaultValue: {
+      type: Array,
+      default: () => []
+    },
+    dbParams: {
+      type: Object
+    },
+    cacheUniqueKey: {
+      type: Object,
+      default: () => {
+        return {};
+      }
+    },
+    formType: {
+      type: Object,
+      default: () => {
+        return {};
+      }
+    },
+    formConfig: {
+      type: Object,
+      default: () => {
+        return {};
+      }
+    },
+    formTableItem: {
+      type: Object,
+      default: () => {
+        return {};
+      }
+    },
+    isDetail: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: ["AddComplete", "formTableBlur", "DeleteComplete"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const $message = useMessage();
+    const { cmps, getComName } = useComponents();
+    useValidate({ message: $message });
+    const isShowEmpty = ref(false);
+    const tableList = ref([]);
+    const fullTableList = ref([]);
+    const multipleSelected = ref({});
+    const columns = ref([]);
+    const columnsLevel = ref(1);
+    const formTableGridRef = ref();
+    function $t(...args) {
+    }
+    const handleRowId = computed(() => {
+      var _a;
+      return ((_a = props.columnConfig) == null ? void 0 : _a.primaryKey) || "field";
+    });
+    computed(() => {
+      return function(name, item) {
+        let tag = cmps[name];
+        return tag ? h(tag, {
+          attrs: { item }
+        }) : null;
+      };
+    });
+    computed(() => {
+      var _a, _b;
+      return (_b = (_a = props.formTableItem) == null ? void 0 : _a.wordbook) == null ? void 0 : _b.idField;
+    });
+    computed(() => {
+      var _a, _b;
+      return ((_b = (_a = props.formTableItem) == null ? void 0 : _a.wordbook) == null ? void 0 : _b.delFlagField) || "deleteKey";
+    });
+    const rowH = computed(() => {
+      var _a;
+      if (props.isDetail || !((_a = tableList.value) == null ? void 0 : _a.length))
+        return 50;
+      let hasTextarea = columns.value.map((item) => {
+        if (item.html_type == "TEXTAREA")
+          return item.initialize_high ? +item.initialize_high : 3;
+        return null;
+      }).filter(Boolean);
+      let MaxH = 50;
+      if (hasTextarea.length) {
+        MaxH = Math.max(...hasTextarea) * 20 + 10 + 4 + 18;
+      }
+      return MaxH;
+    });
+    const minHeight = computed(() => {
+      return rowH.value + columnsLevel.value * 40 + 10 + "px";
+    });
+    const maxHeight = computed(() => {
+      return rowH.value * 6 + columnsLevel.value * 40 + 10 + "px";
+    });
+    const tableHeight = computed(() => {
+      var _a;
+      let len = ((_a = tableList.value) == null ? void 0 : _a.length) || 1;
+      return len * rowH.value + columnsLevel.value * 40 + 10;
+    });
+    function loadColumn(config) {
+      const columnsFormatted = handleGroupColums(columns.value);
+      if (columnsFormatted) {
+        columns.value = columnsFormatted;
+      }
+      const table = formTableGridRef.value;
+      if (!table)
+        return;
+      table && table.reloadColumn(columns.value);
+    }
+    function handleGroupColums(columns2) {
+      var _a;
+      let { rowGroupSetting } = ((_a = props.formTableItem) == null ? void 0 : _a.wordbook) || {};
+      if (!rowGroupSetting || !Object.keys(rowGroupSetting).length)
+        return columns2;
+      let { firstRowGroup, secondRowGroup } = rowGroupSetting;
+      if (!firstRowGroup || !firstRowGroup.length)
+        return columns2;
+      handleRowColumns(firstRowGroup, columns2, "val_key");
+      columnsLevel.value = 2;
+      if (!secondRowGroup || !secondRowGroup.length)
+        return columns2;
+      handleRowColumns(secondRowGroup, columns2, "title");
+      columnsLevel.value = 3;
+      return columns2;
+    }
+    function handleRowColumns(rowColumns, columns2, key) {
+      rowColumns.map((item) => {
+        var _a;
+        let children = [];
+        let spliceIndex = -1;
+        let indexArr = [];
+        ((_a = item.list) == null ? void 0 : _a.length) && item.list.forEach((v) => {
+          let matchItem = columns2.find((column) => column[key] === v);
+          if (matchItem) {
+            let matchIndex = columns2.findIndex((column) => column[key] === v);
+            indexArr.push(matchIndex);
+            delete matchItem.fixed;
+            children.push(matchItem);
+            columns2.splice(matchIndex, 1);
+          }
+        });
+        let obj = {
+          title: $t(item.titleI18n || item.title),
+          visible: true,
+          children
+        };
+        spliceIndex = Math.min.apply(Math, indexArr);
+        spliceIndex > -1 && columns2.splice(spliceIndex, 0, obj);
+      });
+    }
+    async function loadData(list) {
+      if (!list || !list.length)
+        return;
+      tableList.value = vexutils.clone(list, true);
+      fullTableList.value = vexutils.clone(list, true);
+      handlerFieldToggleList(tableList.value);
+      const table = formTableGridRef.value;
+      if (!table)
+        return;
+      await table.loadData(tableList.value);
+      handleMultipleSelected(list, false);
+    }
+    function handleMultipleSelected(list, isAdd) {
+      var _a, _b;
+      let multipleSelectedValue = {};
+      let fieldList = (_b = (_a = props.columnConfig) == null ? void 0 : _a.columns) != null ? _b : [];
+      list.forEach((item, i) => {
+        let field = item.field;
+        multipleSelectedValue[field] = {};
+        for (let key in item) {
+          if (!ignoreKey(key)) {
+            let isSearchMore = fieldList.find((v) => v.val_key === key);
+            if ((isSearchMore == null ? void 0 : isSearchMore.html_type) === "SEARCH_MORE") {
+              multipleSelectedValue[field][key] = [];
+            }
+          }
+        }
+      });
+      if (isAdd) {
+        Object.assign(multipleSelected.value, {
+          ...multipleSelectedValue
+        });
+      } else {
+        multipleSelected.value = multipleSelectedValue;
+      }
+    }
+    function ignoreKey(key) {
+      return key.startsWith("_") && key.endsWith("_") || key == "field";
+    }
+    function handlerClickRow({ row, $event = {}, $rowIndex, triggerCheckbox, triggerTreeNode }) {
+      var _a, _b, _c, _d;
+      let { className } = $event.target || {};
+      $event.preventDefault();
+      $event.stopPropagation();
+      if (className == null ? void 0 : className.includes("vxe-checkbox--icon"))
+        return;
+      let table = formTableGridRef.value;
+      let isChecked = table.isCheckedByCheckboxRow(row);
+      let checkedLen = (_a = table.getCheckboxRecords()) == null ? void 0 : _a.length;
+      let isCheckCell = !triggerCheckbox && (className.includes("col--checkbox") || ((_d = (_c = (_b = $event.target) == null ? void 0 : _b.lastChild) == null ? void 0 : _c.className) == null ? void 0 : _d.includes("vxe-cell--checkbox")));
+      if (isCheckCell)
+        return;
+      table.setAllCheckboxRow(false);
+      if (!checkedLen && !isChecked) {
+        table.setCheckboxRow([row], true);
+        return;
+      }
+      if (checkedLen == 1 && isChecked) {
+        table.setCheckboxRow([row], false);
+        return;
+      }
+      table.setCheckboxRow(row, true);
+    }
+    function handlerFieldToggleList(list) {
+      if (!list.length)
+        return;
+      let { fieldToggleSetting } = props.formConfig || {};
+      if (!fieldToggleSetting || !Object.keys(fieldToggleSetting).length)
+        return;
+      list.forEach((row) => {
+        handlerFieldToggle(fieldToggleSetting, row);
+      });
+    }
+    function handlerFieldToggle(fieldToggleSetting, formData = {}) {
+      const configList = [
+        {
+          key: "is_show",
+          value: true
+        },
+        {
+          key: "is_show",
+          value: false
+        },
+        {
+          key: "is_null",
+          value: false
+        },
+        {
+          key: "is_null",
+          value: true
+        },
+        {
+          key: "is_edit",
+          value: true
+        },
+        {
+          key: "is_edit",
+          value: false
+        }
+      ];
+      const checkList = (list) => list.forEach((l) => {
+      });
+      let resetObj = {};
+      let resetType = {};
+      let fieldObj = formData.__fieldObj__ || {};
+      fieldToggleSetting.forEach((item) => {
+        let FlagList = handleGetFlagRes(item.conObj, formData);
+        let {
+          showField = [],
+          hideField = [],
+          requiredField = [],
+          notRequiredField = [],
+          enabledField = [],
+          disabledField = [],
+          isRestoreDefault = true
+        } = item;
+        let fieldLists = [[], hideField, requiredField, notRequiredField, enabledField, disabledField];
+        const checkArr = [fieldLists];
+        checkArr.forEach((c) => {
+          checkList(c);
+        });
+        let falg = false;
+        falg = FlagList.every((f) => f);
+        if (falg) {
+          showField.forEach((el) => {
+            let findItem = handleGetItem(fieldObj, el);
+            handleSetItem(findItem, configList[0]);
+            resetObj[el] = false;
+          });
+          fieldLists.forEach((f, j) => {
+            f.forEach((el) => {
+              let findItem = handleGetItem(fieldObj, el);
+              if (findItem) {
+                let { key, value } = configList[j];
+                if (key === "is_show" && value === false) {
+                  resetObj[el] = !(isRestoreDefault !== void 0 && !isRestoreDefault);
+                  resetType[el] = findItem.html_type;
+                }
+                handleSetItem(findItem, configList[j]);
+              }
+            });
+          });
+        }
+        resetFields(resetObj, resetType, formData);
+      });
+    }
+    function resetFields(resetObj, resetType, formData) {
+      let fieldObj = formData.__fieldObj__ || {};
+      Object.keys(resetObj || {}).forEach((v) => {
+        if (resetObj[v]) {
+          let defObj = fieldObj[v].__defObj__ || {};
+          if (resetType[v] != "SEARCH") {
+            let errKey = handleGetErrKey(fieldObj[v]);
+            formData[v] = defObj.defVal;
+            fieldObj[v][errKey] = void 0;
+          } else {
+            if (formData[v] != defObj.defVal && resetType[v] == "SEARCH") {
+              if (!formData[v] && !defObj.defVal)
+                return;
+              let errKey = handleGetErrKey(fieldObj[v]);
+              formData[v] = defObj.defVal;
+              fieldObj[v][errKey] = void 0;
+            }
+          }
+        }
+      });
+    }
+    function handleGetErrKey(field = {}) {
+      return `__${field.val_key}-errorMsg__`;
+    }
+    function handleGetItem(fieldObj, el) {
+      return fieldObj[el];
+    }
+    function handleSetItem(findItem, config) {
+      if (!((findItem == null ? void 0 : findItem.val_key) || ""))
+        return;
+      const { key, value } = config;
+      let flagVal = value ? 1 : 0;
+      findItem && (findItem[key] = flagVal);
+    }
+    function handleGetFlagRes(list, formData = {}) {
+      let FlagList = [];
+      if (!Array.isArray(list))
+        return FlagList;
+      list.forEach((ele) => {
+        if (!handleCheckFlag(ele, formData)) {
+          FlagList.push(false);
+        } else {
+          FlagList.push(true);
+        }
+      });
+      return FlagList;
+    }
+    function handleCheckFlag(data = {}, formData = {}) {
+      var _a, _b;
+      const is_number = (val) => !(parseFloat(Number(val) + "").toString() == "NaN");
+      const all_number = (a, b) => is_number(a) && is_number(b);
+      let obj = {
+        table: {
+          ...formData
+        },
+        form: {
+          ...formData
+        },
+        sys: ((_b = (_a = props == null ? void 0 : props.userInfo) == null ? void 0 : _a.map) == null ? void 0 : _b.sysParams) || {},
+        db: props.dbParams || {}
+      };
+      const field_key = data.field_key;
+      let field_val = typeof field_key === "string" && /\${(.*?)}/g.test(field_key) ? vexutils.handleSysParams(field_key, obj) : formData[field_key];
+      let data_value = typeof data.value === "string" ? vexutils.handleSysParams(data.value, obj) : data.value;
+      if (data.con == "EQ") {
+        return field_val == data_value;
+      } else if (data.con == "NEQ") {
+        return field_val != data_value;
+      } else if (data.con == "NULL") {
+        return !field_val && String(field_val) !== "0";
+      } else if (data.con == "NOT_NULL") {
+        return !!field_val || String(field_val) === "0";
+      } else if (data.con == "CL") {
+        return field_val && field_val.includes(data_value);
+      } else if (data.con == "NC") {
+        return !field_val || field_val && !field_val.includes(data_value);
+      } else if (data.con == "BIG") {
+        if (all_number(field_val, data_value)) {
+          return +field_val > +data_value;
+        }
+      } else if (data.con == "BIGEQ") {
+        if (all_number(field_val, data_value)) {
+          return +field_val >= +data_value;
+        }
+      } else if (data.con == "LESS") {
+        if (all_number(field_val, data_value)) {
+          return +field_val < +data_value;
+        }
+      } else if (data.con == "LESSEQ") {
+        if (all_number(field_val, data_value)) {
+          return +field_val <= +data_value;
+        }
+      }
+    }
+    watch(() => props.columnConfig, (config) => {
+      if (!config || !Object.keys(config).length)
+        return;
+      loadColumn();
+    });
+    watch(() => props.data, (value) => {
+      if (!value || !value.length) {
+        isShowEmpty.value = true;
+      }
+      loadData(value);
+    });
+    onMounted(() => {
+      if (!props.isOnlyDisplay)
+        return;
+      loadColumn(props.columnConfig);
+      loadData(props.data);
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["formTable-page", { "formTable-page-disabled--detail": __props.isDetail }]),
+        style: normalizeStyle({ height: unref(tableHeight) + "px", minHeight: unref(minHeight), maxHeight: unref(maxHeight) })
+      }, [
+        createVNode(unref(CGrid), {
+          ref_key: "formTableGridRef",
+          ref: formTableGridRef,
+          style: { height: "100%" },
+          border: "",
+          "show-header-overflow": "",
+          "highlight-hover-row": "",
+          "highlight-current-row": "",
+          "show-footer-overflow": "title",
+          height: "auto",
+          resizable: "",
+          "auto-resize": "",
+          "row-id": unref(handleRowId),
+          "row-key": true,
+          "checkbox-config": {
+            trigger: "cell",
+            reserve: true,
+            highlight: true
+          },
+          onCellClick: handlerClickRow
+        }, {
+          empty: withCtx(() => [
+            isShowEmpty.value ? (openBlock(), createElementBlock("div", _hoisted_1, "\u6682\u65E0\u6570\u636E")) : createCommentVNode("v-if", true)
+          ]),
+          _: 1
+        }, 8, ["row-id"])
+      ], 6);
+    };
+  }
+});
+var script = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "FormTable.vue"]]);
+
+export { script as default };

package/es/packages/form-table/src/components/index.js

@@ -1,49 +1,35 @@
 import configData from '../configs/index.js';
-import './table-age.js';
-import './table-date-picker.js';
-import './table-digital.js';
-import './table-input.js';
-import './table-input-password.js';
-import './table-month-picker.js';
-import './table-search.js';
-import './table-search-more.js';
-import './table-select.js';
-import './table-select-multiple.js';
-import './table-textarea.js';
-import './table-time-picker.js';
-import './table-tree-select.js';
-import './text-over-tooltip.js';
-import script from './table-age.vue_vue_type_script_setup_true_lang.js';
-import script$1 from './table-date-picker.vue_vue_type_script_setup_true_lang.js';
-import script$2 from './table-digital.vue_vue_type_script_setup_true_lang.js';
-import script$3 from './table-input.vue_vue_type_script_setup_true_lang.js';
-import script$4 from './table-input-password.vue_vue_type_script_setup_true_lang.js';
-import script$5 from './table-month-picker.vue_vue_type_script_setup_true_lang.js';
-import script$6 from './table-search.vue_vue_type_script_setup_true_lang.js';
-import script$7 from './table-search-more.vue_vue_type_script_setup_true_lang.js';
-import script$8 from './table-select.vue_vue_type_script_setup_true_lang.js';
-import script$9 from './table-select-multiple.vue_vue_type_script_setup_true_lang.js';
-import script$a from './table-textarea.vue_vue_type_script_setup_true_lang.js';
-import script$b from './table-time-picker.vue_vue_type_script_setup_true_lang.js';
-import script$c from './table-tree-select.vue_vue_type_script_setup_true_lang.js';
-import script$d from './text-over-tooltip.vue_vue_type_script_setup_true_lang.js';
+import tableAge from './table-age.js';
+import tableDatePicker from './table-date-picker.js';
+import tableDigital from './table-digital.js';
+import tableInput from './table-input.js';
+import tableInputPassword from './table-input-password.js';
+import tableMonthPicker from './table-month-picker.js';
+import tableSearch from './table-search.js';
+import tableSearchMore from './table-search-more.js';
+import tableSelect from './table-select.js';
+import tableSelectMultiple from './table-select-multiple.js';
+import tableTextarea from './table-textarea.js';
+import tableTimePicker from './table-time-picker.js';
+import tableTreeSelect from './table-tree-select.js';
+import textOverTooltip from './text-over-tooltip.js';
 
 function useComponents() {
   const cmps = {
-    tableAge: script,
-    tableDatePicker: script$1,
-    tableDigital: script$2,
-    tableInput: script$3,
-    tableInputPassword: script$4,
-    tableMonthPicker: script$5,
-    tableSearch: script$6,
-    tableSearchMore: script$7,
-    tableSelect: script$8,
-    tableSelectMultiple: script$9,
-    tableTextarea: script$a,
-    tableTimePicker: script$b,
-    tableTreeSelect: script$c,
-    textOverTooltip: script$d
+    tableAge,
+    tableDatePicker,
+    tableDigital,
+    tableInput,
+    tableInputPassword,
+    tableMonthPicker,
+    tableSearch,
+    tableSearchMore,
+    tableSelect,
+    tableSelectMultiple,
+    tableTextarea,
+    tableTimePicker,
+    tableTreeSelect,
+    textOverTooltip
   };
   function getComName(v = {}) {
     return configData.getComName(v);