cnhis-design-vue 3.1.14-beta.2 → 3.1.14-beta.5

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

@@ -0,0 +1,67 @@
+const configData = {
+  comTypeMap: {
+    INPUT: "tableInput",
+    DIGITAL: "tableDigital",
+    TEXTAREA: "tableTextarea",
+    RADIO: "tableSelect",
+    RADIO_BLOCK: "tableSelect",
+    CHECKBOX_BLOCK: "tableSelectMultiple",
+    CHECKBOX: "tableSelectMultiple",
+    SEARCH: "tableSearch",
+    SEARCH_MORE: "tableSearchMore",
+    DATE: "tableDatePicker",
+    "DATE-INPUT": "tableDatePicker",
+    "DATETIME-INPUT": "tableDatePicker",
+    SELECT: "tableSelect",
+    PHONE_TYPE: "tableSelect",
+    IDCARD_TYPE: "tableSelect",
+    tableMonthPicker: "tableMonthPicker",
+    tableTimePicker: "tableTimePicker",
+    tableDatePicker: "tableDatePicker",
+    tableSelect: "tableSelect",
+    tableInputPassword: "tableInputPassword",
+    tableSelectMultiple: "tableSelectMultiple",
+    AGE: "tableAge"
+  },
+  getComName(v = {}) {
+    const { isMonthPicker_com, isDate_com, isTimePicker_com, isSelect_com, isPassword_com, isTreeSelect_com } = this;
+    const { comTypeMap } = configData;
+    if (isDate_com(v.html_type)) {
+      if (isMonthPicker_com(v))
+        return "tableMonthPicker";
+      if (isTimePicker_com(v))
+        return "tableTimePicker";
+      return "tableDatePicker";
+    }
+    if (isSelect_com(v))
+      return "tableSelect";
+    if (isTreeSelect_com(v))
+      return "tableTreeSelect";
+    const res = comTypeMap[v.html_type];
+    if (res) {
+      return res;
+    }
+    return "tableInput";
+  },
+  isMonthPicker_com(v) {
+    return v.date_format && v.date_format.replace(/yyyy-MM/gi, "YYYY-MM") == "YYYY-MM";
+  },
+  isDate_com(key) {
+    return key === "DATE" || key === "DATE-INPUT" || key === "DATETIME-INPUT";
+  },
+  isTimePicker_com(v) {
+    return v.html_type == "TIME-INPUT" || v.date_format == "HH:mm:ss" || v.date_format == "HH:mm";
+  },
+  isSelect_com(v) {
+    return ["SELECT", "PHONE_TYPE", "IDCARD_TYPE"].includes(v.html_type);
+  },
+  isPassword_com(v) {
+    var _a;
+    return (((_a = v == null ? void 0 : v.validate) == null ? void 0 : _a.obj_type) || "") === "password";
+  },
+  isTreeSelect_com(v) {
+    return ((v == null ? void 0 : v.show_type) || "") == "tree" && (v == null ? void 0 : v.html_type) == "SEARCH";
+  }
+};
+
+export { configData as default };

package/es/packages/form-table/src/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export * from './useBoundDate';
+export * from './useItemDefault';
+export * from './useValidate';
+export * from './useDateType';
+export * from './useSearch';

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

@@ -0,0 +1,5 @@
+export { useBoundDate } from './useBoundDate.js';
+export { useItemDefault } from './useItemDefault.js';
+export { useValidate } from './useValidate.js';
+export { useDateType } from './useDateType.js';
+export { useSearch } from './useSearch.js';

package/es/packages/form-table/src/hooks/useBoundDate.d.ts

@@ -0,0 +1,21 @@
+import { AnyObject } from '../../../../../es/src/types';
+export declare function useBoundDate({ row, defaultFieldList }: {
+    row: AnyObject;
+    defaultFieldList: AnyObject[];
+}, handlerGetDateType: (item: AnyObject) => any, handleSetFieldsValue: (value: AnyObject, item: AnyObject) => any): {
+    isBoundDate: (v: any, item: AnyObject) => void;
+    handleDateClearBtn: (v: any, item: AnyObject) => void;
+    handleStartDateEndDate: (item: AnyObject) => void;
+    showTimePanel: (item: AnyObject) => boolean;
+    momentLib: (date_format: string) => any;
+    judgeTimeBoundary: (time: any, item: AnyObject) => void;
+    setTimeValue: (time: any, item: AnyObject) => void;
+    judgeTimeRange: (time: any, item: AnyObject) => AnyObject | undefined;
+    isSameDate: (curDate: any, compareMin: any, compareMax: any) => AnyObject;
+    setDefaultCurrent: (compareItem: AnyObject, currTime: any) => void;
+    handleDefaultRimeRange: (time: any, item: AnyObject) => void;
+    judgeMinMaxDateIsSameDate: (item: AnyObject) => boolean;
+    handleDefaultTimeRange: (time: any, item: any, chooseDate?: any) => {};
+    changeTimeDate: (time: any, minTime: any, maxTime: any, item: AnyObject) => {};
+    setTimeRangeArr: (hMin: any, HMax: any, mMin: any, mMax: any, sMin: any, sMax: any) => Required<Partial<Record<"hArr" | "mArr" | "sArr", [any, any]>>>;
+};

package/es/packages/form-table/src/hooks/useBoundDate.js

@@ -0,0 +1,414 @@
+import moment from 'moment';
+
+function useBoundDate({
+  row,
+  defaultFieldList
+}, handlerGetDateType, handleSetFieldsValue) {
+  function isBoundDate(v, item) {
+    handleDateClearBtn(v, item);
+    if (!v || v.type === "blur" || !item)
+      return;
+    const attrList = ["startDate", "endDate"];
+    if (item.html_type === "DATE" && attrList.includes(item.attr)) {
+      handleStartDateEndDate(item);
+    }
+  }
+  function handleDateClearBtn(v, item) {
+    const dateObj = {
+      startDate: "min_date",
+      endDate: "max_date"
+    };
+    if (row[item.val_key]) {
+      let compareArr = [];
+      let compareArrCopy = [];
+      let curTime = "";
+      if (item.attr === "startDate") {
+        compareArr = defaultFieldList.filter((v2) => item.group == v2.group && v2.attr === "endDate");
+        compareArrCopy = defaultFieldList.filter((v2) => item.group == v2.group && v2.attr === "endDate");
+      } else if (item.attr === "endDate") {
+        compareArr = defaultFieldList.filter((v2) => item.group == v2.group && v2.attr === "startDate");
+        compareArrCopy = defaultFieldList.filter((v2) => item.group == v2.group && v2.attr === "startDate");
+      }
+      if (compareArrCopy.length && compareArr.length) {
+        let curValidate = compareArrCopy[0].validate;
+        if (curValidate) {
+          curTime = curValidate[dateObj[item.attr]] === "currTime" ? "currTime" : "";
+        }
+        compareArr.forEach((v2) => {
+          if (v2.validate) {
+            v2.validate[dateObj[item.attr]] = curTime;
+            v2.validate.isSpliceHour = false;
+          }
+        });
+      }
+    }
+  }
+  function handleStartDateEndDate(item) {
+    const time = row[item.val_key].valueOf();
+    const dateObj = {
+      startDate: "min_date",
+      endDate: "max_date"
+    };
+    const date_format = momentLib(item.date_format);
+    const matchArr = defaultFieldList.filter((v) => item.group == v.group && v.attr === item.attr);
+    let compareArr = [];
+    if (item.attr === "startDate") {
+      compareArr = defaultFieldList.filter((v) => item.group == v.group && v.attr === "endDate");
+    } else if (item.attr === "endDate") {
+      compareArr = defaultFieldList.filter((v) => item.group == v.group && v.attr === "startDate");
+    }
+    if (!item.validate)
+      return;
+    setDefaultCurrent(compareArr[0], item.validate.currTime);
+    if (item.date_format === "YYYY-MM-dd HH:mm:ss") {
+      handleDefaultRimeRange(time, item);
+    }
+    compareArr.forEach((v) => {
+      if (v.validate) {
+        Reflect.set(v.validate, dateObj[item.attr], time);
+        Reflect.set(v.validate, "momentFormat", date_format);
+        v.validate[dateObj[item.attr]] = time;
+        v.validate.momentFormat = date_format;
+      }
+    });
+    matchArr.forEach((v) => {
+      if (v.validate) {
+        v.validate.momentFormat = date_format;
+      }
+    });
+    if ((item.date_format === "HH:mm:ss" || item.date_format === "HH:mm") && item.validate && item.validate.setCurrTime) {
+      item.validate.timeRange = handleDefaultTimeRange(time, item);
+    }
+    if (showTimePanel(item)) {
+      const { chooseDate } = judgeTimeRange(time, compareArr[0]) || {};
+      const compareTimeRange = handleDefaultTimeRange(time, compareArr[0], chooseDate);
+      compareArr.forEach((v) => {
+        if (v.validate) {
+          Reflect.set(v.validate, "timeRange", compareTimeRange);
+          v.validate.timeRange = compareTimeRange;
+        }
+      });
+      judgeTimeBoundary(time, item);
+    }
+  }
+  function showTimePanel(item) {
+    return item.date_format === "HH:mm:ss" || item.date_format === "HH:mm" || item.date_format === "YYYY-MM-dd HH:mm:ss";
+  }
+  function momentLib(date_format) {
+    let res;
+    switch (date_format) {
+      case "YYYY-MM-dd HH:mm:ss":
+      case "HH:mm:ss":
+        res = "days";
+        break;
+      case "YYYY-MM-dd":
+        res = "days";
+        break;
+      case "YYYY-MM":
+        res = "months";
+        break;
+    }
+    return res;
+  }
+  function judgeTimeBoundary(time, item) {
+    if (!item || item.validate)
+      return;
+    const { currTime } = item.validate;
+    if (item.validate.min_date === "currTime") {
+      if (time < currTime) {
+        setTimeValue(currTime, item);
+      }
+    } else if (item.validate.min_date) {
+      if (time < item.validate.min_date) {
+        setTimeValue(item.validate.min_date, item);
+      }
+    }
+    if (item.validate.max_date === "currTime") {
+      if (time > currTime) {
+        setTimeValue(currTime, item);
+      }
+    } else if (item.validate.max_date) {
+      if (time > item.validate.max_date) {
+        setTimeValue(item.validate.max_date, item);
+      }
+    }
+  }
+  function setTimeValue(time, item) {
+    const dateType = handlerGetDateType(item);
+    const value = moment(time).format(dateType);
+    const momentValue = moment(value, dateType);
+    const key = item["val_key"];
+    setTimeout(() => {
+      handleSetFieldsValue({ [key]: momentValue }, item);
+    }, 20);
+  }
+  function judgeTimeRange(time, item) {
+    const resObj = {};
+    const curDate = moment(time).format("YYYY-MM-DD");
+    if (!item || !item.validate)
+      return resObj;
+    if (!item.validate.min_date && !item.validate.max_date) {
+      resObj.res = false;
+      return resObj;
+    } else if (item.validate.min_date && item.validate.max_date) {
+      let compareMin, compareMax;
+      if (item.validate.min_date !== "currTime" && item.validate.max_date !== "currTime") {
+        compareMin = moment(item.validate.min_date).format("YYYY-MM-DD");
+        compareMax = moment(item.validate.max_date).format("YYYY-MM-DD");
+        return isSameDate(curDate, compareMin, compareMax);
+      } else if (item.validate.min_date !== "currTime" && item.validate.max_date == "currTime") {
+        compareMin = moment(item.validate.min_date).format("YYYY-MM-DD");
+        compareMax = moment(item.validate.currTime).format("YYYY-MM-DD");
+        return isSameDate(curDate, compareMin, compareMax);
+      } else if (item.validate.min_date === "currTime" && item.validate.max_date !== "currTime") {
+        compareMin = moment(item.validate.currTime).format("YYYY-MM-DD");
+        compareMax = moment(item.validate.max_date).format("YYYY-MM-DD");
+        return isSameDate(curDate, compareMin, compareMax);
+      } else {
+        resObj.res = false;
+        return resObj;
+      }
+    } else if (item.validate.min_date) {
+      let compareMin;
+      if (item.validate.min_date === "currTime") {
+        compareMin = moment(item.validate.currTime).format("YYYY-MM-DD");
+      } else {
+        compareMin = moment(item.validate.min_date).format("YYYY-MM-DD");
+      }
+      return isSameDate(curDate, compareMin, "");
+    } else if (item.validate.max_date) {
+      let compareMax;
+      if (item.validate.max_date === "currTime") {
+        compareMax = moment(item.validate.currTime).format("YYYY-MM-DD");
+      } else {
+        compareMax = moment(item.validate.max_date).format("YYYY-MM-DD");
+      }
+      return isSameDate(curDate, "", compareMax);
+    }
+  }
+  function isSameDate(curDate, compareMin, compareMax) {
+    const resObj = {};
+    if (compareMin && compareMax) {
+      resObj.res = curDate === compareMin || curDate === compareMax;
+      if (curDate === compareMin && curDate === compareMax) {
+        resObj.chooseDate = "";
+      } else if (curDate === compareMin) {
+        resObj.chooseDate = "min_date";
+      } else if (curDate === compareMax) {
+        resObj.chooseDate = "max_date";
+      } else {
+        resObj.chooseDate = "";
+      }
+    } else if (compareMin) {
+      if (curDate === compareMin) {
+        resObj.chooseDate = "min_date";
+        resObj.res = true;
+      } else {
+        resObj.chooseDate = "";
+        resObj.res = false;
+      }
+    } else if (compareMax) {
+      if (curDate === compareMax) {
+        resObj.chooseDate = "max_date";
+        resObj.res = true;
+      } else {
+        resObj.chooseDate = "";
+        resObj.res = false;
+      }
+    }
+    return resObj;
+  }
+  function setDefaultCurrent(compareItem, currTime) {
+    if (!compareItem)
+      return;
+    const validate = (compareItem == null ? void 0 : compareItem.validate) || {};
+    if ((validate == null ? void 0 : validate.min_date) === "currTime" || (validate == null ? void 0 : validate.max_date) === "currTime") {
+      validate.currTime = currTime;
+    }
+  }
+  function handleDefaultRimeRange(time, item) {
+    if (!item.validate)
+      return;
+    if (judgeMinMaxDateIsSameDate(item)) {
+      item.validate.timeRange = handleDefaultTimeRange(time, item);
+    } else {
+      const { res, chooseDate } = judgeTimeRange(time, item) || {};
+      if (res) {
+        item.validate.timeRange = handleDefaultTimeRange(time, item, chooseDate);
+      } else {
+        item.validate.timeRange = {};
+      }
+    }
+  }
+  function judgeMinMaxDateIsSameDate(item) {
+    if (!item || !item.validate)
+      return false;
+    if (item.validate.min_date && item.validate.min_date) {
+      let compareMin, compareMax;
+      if (item.validate.min_date !== "currTime" && item.validate.max_date !== "currTime") {
+        compareMin = moment(item.validate.min_date).format("YYYY-MM-DD");
+        compareMax = moment(item.validate.max_date).format("YYYY-MM-DD");
+        return compareMin === compareMax;
+      } else if (item.validate.min_date !== "currTime" && item.validate.max_date == "currTime") {
+        compareMin = moment(item.validate.min_date).format("YYYY-MM-DD");
+        compareMax = moment(item.validate.currTime).format("YYYY-MM-DD");
+        return compareMin === compareMax;
+      } else if (item.validate.min_date === "currTime" && item.validate.max_date !== "currTime") {
+        compareMin = moment(item.validate.currTime).format("YYYY-MM-DD");
+        compareMax = moment(item.validate.max_date).format("YYYY-MM-DD");
+        return compareMin === compareMax;
+      } else {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  }
+  function handleDefaultTimeRange(time, item, chooseDate) {
+    let timeRange = {};
+    if (!item || !item.validate)
+      return {};
+    const { currTime } = item.validate;
+    if (item.validate.min_date && !item.validate.max_date) {
+      if (item.validate.min_date === "currTime") {
+        timeRange = changeTimeDate(time, currTime, "", item);
+      } else if (item.validate.min_date) {
+        timeRange = changeTimeDate(time, item.validate.min_date, "", item);
+      }
+    } else if (!item.validate.min_date && item.validate.max_date) {
+      if (item.validate.max_date === "currTime") {
+        timeRange = changeTimeDate(time, "", currTime, item);
+      } else if (item.validate.max_date) {
+        timeRange = changeTimeDate(time, "", item.validate.max_date, item);
+      }
+    } else if (item.validate.min_date && item.validate.max_date) {
+      if (item.validate.min_date === "currTime" && item.validate.max_date !== "currTime") {
+        if (chooseDate) {
+          if (chooseDate === "max_date") {
+            timeRange = changeTimeDate(time, "", item.validate.max_date, item);
+          } else if (chooseDate === "min_date") {
+            timeRange = changeTimeDate(time, currTime, "", item);
+          }
+        } else {
+          timeRange = changeTimeDate(time, currTime, item.validate.max_date, item);
+        }
+      } else if (item.validate.min_date !== "currTime" && item.validate.max_date === "currTime") {
+        if (chooseDate) {
+          if (chooseDate === "max_date") {
+            timeRange = changeTimeDate(time, "", currTime, item);
+          } else if (chooseDate === "min_date") {
+            timeRange = changeTimeDate(time, item.validate.min_date, "", item);
+          }
+        } else {
+          timeRange = changeTimeDate(time, item.validate.min_date, currTime, item);
+        }
+      } else if (item.validate.min_date !== "currTime" && item.validate.max_date !== "currTime") {
+        if (chooseDate) {
+          if (chooseDate === "max_date") {
+            timeRange = changeTimeDate(time, "", item.validate.max_date, item);
+          } else if (chooseDate === "min_date") {
+            timeRange = changeTimeDate(time, item.validate.min_date, "", item);
+          }
+        } else {
+          timeRange = changeTimeDate(time, item.validate.min_date, item.validate.max_date, item);
+        }
+      }
+    }
+    return timeRange;
+  }
+  function changeTimeDate(time, minTime, maxTime, item) {
+    const h = moment(time).hour();
+    const m = moment(time).minute();
+    let minH = 0;
+    let maxH = 24;
+    let minM = 0;
+    let maxM = 60;
+    let minS = 0;
+    let maxS = 60;
+    let timeRange = {};
+    Reflect.set(item.validate, "isSpliceHour", false);
+    if (minTime && !maxTime) {
+      if (time > moment(minTime).endOf("day").valueOf()) {
+        return setTimeRangeArr(0, 0, 0, 0, 0, 0);
+      }
+      minH = moment(minTime).hour();
+      minM = moment(minTime).minute();
+      minS = moment(minTime).second();
+      if (h == minH) {
+        if (m > minM) {
+          timeRange = setTimeRangeArr(0, minH, 0, minM, 0, 0);
+        } else {
+          timeRange = setTimeRangeArr(0, minH, 0, minM, 0, minS + 1);
+        }
+      } else {
+        timeRange = setTimeRangeArr(0, minH, 0, 0, 0, 0);
+      }
+    } else if (!minTime && maxTime) {
+      if (time < moment(maxTime).startOf("day").valueOf()) {
+        return setTimeRangeArr(0, 0, 0, 0, 0, 0);
+      }
+      maxH = moment(maxTime).hour();
+      maxM = moment(maxTime).minute();
+      maxS = moment(maxTime).second();
+      if (h == maxH) {
+        if (m < maxM) {
+          timeRange = setTimeRangeArr(maxH + 1, 24, maxM + 1, 60, 0, 0);
+        } else {
+          timeRange = setTimeRangeArr(maxH + 1, 24, maxM + 1, 60, maxS, 60);
+        }
+      } else {
+        timeRange = setTimeRangeArr(maxH + 1, 24, 0, 0, 0, 0);
+      }
+    } else if (minTime && maxTime) {
+      minH = moment(minTime).hour();
+      minM = moment(minTime).minute();
+      minS = moment(minTime).second();
+      maxH = moment(maxTime).hour();
+      maxM = moment(maxTime).minute();
+      maxS = moment(maxTime).second();
+      Reflect.set(item.validate, "isSpliceHour", true);
+      if (h === maxH) {
+        if (m < maxM) {
+          timeRange = setTimeRangeArr(minH, maxH, maxM + 1, 60, 0, 0);
+        } else {
+          timeRange = setTimeRangeArr(minH, maxH, maxM + 1, 60, maxS, 60);
+        }
+      } else if (h === minH) {
+        if (m > minM) {
+          timeRange = setTimeRangeArr(minH, maxH, 0, minM, 0, 0);
+        } else {
+          timeRange = setTimeRangeArr(minH, maxH, 0, minM, 0, minS + 1);
+        }
+      } else {
+        timeRange = setTimeRangeArr(minH, maxH, 0, 0, 0, 0);
+      }
+    }
+    return timeRange;
+  }
+  function setTimeRangeArr(hMin, HMax, mMin, mMax, sMin, sMax) {
+    const timeRange = {};
+    timeRange.hArr = [hMin, HMax];
+    timeRange.mArr = [mMin, mMax];
+    timeRange.sArr = [sMin, sMax];
+    return timeRange;
+  }
+  return {
+    isBoundDate,
+    handleDateClearBtn,
+    handleStartDateEndDate,
+    showTimePanel,
+    momentLib,
+    judgeTimeBoundary,
+    setTimeValue,
+    judgeTimeRange,
+    isSameDate,
+    setDefaultCurrent,
+    handleDefaultRimeRange,
+    judgeMinMaxDateIsSameDate,
+    handleDefaultTimeRange,
+    changeTimeDate,
+    setTimeRangeArr
+  };
+}
+
+export { useBoundDate };

package/es/packages/form-table/src/hooks/useDateType.d.ts

@@ -0,0 +1,17 @@
+import { AnyObject } from '../../../../../es/src/types';
+import { Ref } from 'vue';
+export declare function useDateType(openRef: Ref): {
+    disabledDatePicker: (current: any, item: AnyObject) => any;
+    disabledTimePicker: (current: any, item: AnyObject) => {
+        disabledHours: () => never[];
+        disabledMinutes: () => never[];
+        disabledSeconds: () => never[];
+    } | undefined;
+    openTimeChange: (open: any, item: AnyObject) => void;
+    disabledHours: (item: AnyObject, type: string) => (() => never[]) | undefined;
+    disabledMethodTimeRange: (item: AnyObject) => void;
+    handleCompareTimeRange: (time: any, item: AnyObject, type: string) => {};
+    setTimeRangeArr: (hMin: any, HMax: any, mMin: any, mMax: any, sMin: any, sMax: any) => Required<Partial<Record<"hArr" | "mArr" | "sArr", [any, any]>>>;
+    range: (start: number, end: number) => never[];
+    openDateChange: (open: any, item: AnyObject) => void;
+};