cnhis-design-vue 3.1.17-beta.9 → 3.1.18-beta.3

package/es/components/form-table/src/configs/index.d.ts

@@ -0,0 +1,35 @@
+import { AnyObject } from '../../../../../es/shared/types';
+declare const configData: {
+    comTypeMap: {
+        INPUT: string;
+        DIGITAL: string;
+        TEXTAREA: string;
+        RADIO: string;
+        RADIO_BLOCK: string;
+        CHECKBOX_BLOCK: string;
+        CHECKBOX: string;
+        SEARCH: string;
+        SEARCH_MORE: string;
+        DATE: string;
+        'DATE-INPUT': string;
+        'DATETIME-INPUT': string;
+        SELECT: string;
+        PHONE_TYPE: string;
+        IDCARD_TYPE: string;
+        tableMonthPicker: string;
+        tableTimePicker: string;
+        tableDatePicker: string;
+        tableSelect: string;
+        tableInputPassword: string;
+        tableSelectMultiple: string;
+        AGE: string;
+    };
+    getComName(v?: AnyObject): any;
+    isMonthPicker_com(v: AnyObject): any;
+    isDate_com(key: string): boolean;
+    isTimePicker_com(v: AnyObject): boolean;
+    isSelect_com(v: AnyObject): boolean;
+    isPassword_com(v?: AnyObject): boolean;
+    isTreeSelect_com(v?: AnyObject): boolean;
+};
+export default configData;

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

@@ -0,0 +1,21 @@
+import { AnyObject } from '../../../../../es/shared/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/components/form-table/src/hooks/useDateType.d.ts

@@ -0,0 +1,17 @@
+import { AnyObject } from '../../../../../es/shared/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;
+};

package/es/components/form-table/src/hooks/useDateType.js

@@ -0,0 +1,160 @@
+import moment from 'moment';
+import { nextTick } from 'vue';
+import XEUtils from 'xe-utils';
+
+function useDateType(openRef) {
+  function disabledDatePicker(current, item) {
+    var _a;
+    if (!item.validate)
+      return;
+    const momentFormat = ((_a = item == null ? void 0 : item.validate) == null ? void 0 : _a.momentFormat) || "days";
+    if (!item.validate.max_date && item.validate.min_date) {
+      if (item.validate.min_date === "currTime") {
+        return current && current < moment().startOf(momentFormat);
+      } else if (item.validate.min_date) {
+        return current && current < moment(item.validate.min_date);
+      }
+    }
+    if (!item.validate.min_date && item.validate.max_date) {
+      if (item.validate.max_date === "currTime") {
+        return current >= moment().endOf(momentFormat);
+      } else if (item.validate.max_date) {
+        return current && current >= moment(item.validate.max_date).endOf(momentFormat);
+      }
+    }
+    if (item.validate.min_date && item.validate.max_date) {
+      if (item.validate.min_date != "currTime" && item.validate.max_date != "currTime") {
+        return current && current < moment(item.validate.min_date) || current && current >= moment(item.validate.max_date).endOf(momentFormat);
+      } else if (item.validate.min_date == "currTime" && item.validate.max_date != "currTime") {
+        return current && current < moment().startOf("days") || current && current >= moment(item.validate.max_date).endOf(momentFormat);
+      } else if (item.validate.min_date != "currTime" && item.validate.max_date == "currTime") {
+        return current && current < moment(item.validate.min_date) || current >= moment().endOf(momentFormat);
+      } else if (item.validate.min_date == "currTime" && item.validate.max_date == "currTime") {
+        return current && current < moment().startOf("days") || current >= moment().endOf(momentFormat);
+      }
+    }
+  }
+  function disabledTimePicker(current, item) {
+    var _a;
+    if (!item.validate)
+      return;
+    if (item.date_format === "YYYY-MM-dd HH:mm:ss") {
+      if (XEUtils.isEmpty(item.validate.timeRange) || !item.validate.isSpliceHour) {
+        disabledMethodTimeRange(item);
+      }
+    }
+    const { timeRange = {} } = item.validate;
+    if (!XEUtils.isEmpty(timeRange)) {
+      const { hArr = [], mArr = [], sArr = [] } = timeRange;
+      let hRange = range(hArr[0], hArr[1]);
+      if (item.date_format === "YYYY-MM-dd HH:mm:ss") {
+        if (item.validate.isSpliceHour) {
+          const length = hArr[1] - hArr[0];
+          const tempRange = range(0, 24);
+          tempRange.splice(hArr[0], length + 1);
+          hRange = tempRange;
+        }
+      }
+      let diff = 0;
+      if (["startDate", "endDate"].includes(item.attr) && "currTime" == ((_a = item == null ? void 0 : item.validate) == null ? void 0 : _a.min_date)) {
+        diff = 1;
+      }
+      return {
+        disabledHours: () => hRange,
+        disabledMinutes: () => range(mArr[0], mArr[1] - diff),
+        disabledSeconds: () => range(sArr[0], sArr[1] - diff * 5)
+      };
+    }
+  }
+  function openTimeChange(open, item) {
+    openRef.value = open;
+    if (!item.validate)
+      return;
+    if (!open) {
+      nextTick(() => {
+        Reflect.set(item.validate, "setCurrTime", false);
+      });
+    }
+  }
+  function disabledHours(item, type) {
+    if (!item.validate)
+      return;
+    if (XEUtils.isEmpty(item.validate.timeRange) || !item.validate.isSpliceHour) {
+      disabledMethodTimeRange(item);
+    }
+    const { timeRange = {} } = item.validate;
+    if (!XEUtils.isEmpty(timeRange)) {
+      const { hArr = [], mArr = [], sArr = [] } = timeRange;
+      let hRange = range(hArr[0], hArr[1]);
+      if (item.validate.min_date && item.validate.max_date) {
+        const length = hArr[1] - hArr[0];
+        const tempRange = range(0, 24);
+        tempRange.splice(hArr[0], length + 1);
+        hRange = tempRange;
+      }
+      if (type === "h") {
+        return () => hRange;
+      } else if (type === "m") {
+        return () => range(mArr[0], mArr[1]);
+      } else if (type === "s") {
+        return () => range(sArr[0], sArr[1]);
+      }
+    }
+  }
+  function disabledMethodTimeRange(item) {
+    const currTime = new Date().valueOf();
+    if (!item.validate)
+      return;
+    if ((item.validate.max_date === "currTime" && item.attr === "startDate" || item.validate.min_date === "currTime" && item.attr === "endDate") && !item.validate.setCurrTime) {
+      Reflect.set(item.validate, "setCurrTime", true);
+      item.validate.timeRange = handleCompareTimeRange(currTime, item, "match");
+      item.validate.currTime = currTime;
+    }
+    if ((item.validate.min_date === "currTime" && item.attr === "startDate" || item.validate.max_date === "currTime" && item.attr === "endDate") && !item.validate.setCurrTime) {
+      Reflect.set(item.validate, "setCurrTime", true);
+      item.validate.timeRange = handleCompareTimeRange(currTime, item, "compare");
+      item.validate.currTime = currTime;
+    }
+  }
+  function handleCompareTimeRange(time, item, type) {
+    let timeRange = {};
+    const h = moment(time).hour();
+    const m = moment(time).minute();
+    const s = moment(time).second();
+    if (type === "compare" && item.attr === "startDate" || type === "match" && item.attr === "endDate") {
+      timeRange = setTimeRangeArr(0, h, 0, m, 0, s + 1);
+    } else if (type === "compare" && item.attr === "endDate" || type === "match" && item.attr === "startDate") {
+      timeRange = setTimeRangeArr(h + 1, 24, m + 1, 60, s, 60);
+    }
+    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;
+  }
+  function range(start, end) {
+    const result = [];
+    for (let i = start; i < end; i++) {
+      result.push(i);
+    }
+    return result;
+  }
+  function openDateChange(open, item) {
+  }
+  return {
+    disabledDatePicker,
+    disabledTimePicker,
+    openTimeChange,
+    disabledHours,
+    disabledMethodTimeRange,
+    handleCompareTimeRange,
+    setTimeRangeArr,
+    range,
+    openDateChange
+  };
+}
+
+export { useDateType };

package/es/components/form-table/src/hooks/useFormCommon.d.ts

@@ -0,0 +1,14 @@
+import { AnyObject } from '../../../../../es/shared/types';
+export declare function useFormCommon({ item, row, defaultValue, defaultFieldList }: {
+    item: AnyObject;
+    row: AnyObject;
+    defaultValue: AnyObject;
+    defaultFieldList: AnyObject[];
+}): {
+    handleSetFieldsValue: (setObj?: AnyObject, target?: any) => void;
+    handleCheckKeyInform: (key: string) => boolean;
+    handleGetJsonStr: (str: string | AnyObject) => AnyObject;
+    handlerGetDateType: (data: AnyObject) => any;
+    transformStr: (item: AnyObject) => any;
+    handleGetTargetList: (t?: AnyObject) => AnyObject[];
+};

package/es/components/form-table/src/hooks/useFormCommon.js

@@ -0,0 +1,101 @@
+import XEUtils from 'xe-utils';
+import 'moment';
+
+function useFormCommon({
+  item,
+  row,
+  defaultValue,
+  defaultFieldList
+}) {
+  function handleSetFieldsValue(setObj = {}, target) {
+    const setVal = { ...setObj };
+    if (typeof setVal === "object") {
+      let list = Object.entries(setVal || {});
+      list.forEach((f) => {
+        let [key, value] = f;
+        if (!key)
+          return;
+        if (handleCheckKeyInform(key)) {
+          row[key] = value;
+        } else {
+          if (item) {
+            defaultValue[item.name] = value;
+          } else {
+            if (row[key]) {
+              let name = row[key].name;
+              name && (defaultValue[name] = value);
+            }
+          }
+        }
+        row[key] = value;
+      });
+    }
+  }
+  function handleCheckKeyInform(key) {
+    let baserFormKeys = row;
+    let keyList = Object.keys(baserFormKeys || {});
+    return keyList.includes(key);
+  }
+  function handleGetTargetList(t = {}) {
+    if (t.group) {
+      return defaultFieldList.filter((v) => v.group == t.group);
+    }
+    return defaultFieldList || [];
+  }
+  function transformStr(item2) {
+    const def = defaultValue[item2.name];
+    const propsDef = def || def !== "" && def == 0 ? def : item2.default_val;
+    let defVal = propsDef || propsDef == 0 ? propsDef : "";
+    defVal = String(defVal);
+    return defVal;
+  }
+  function handlerGetDateType(data) {
+    let dateType;
+    switch (data.html_type) {
+      case "DATETIME-INPUT":
+        dateType = "YYYY-MM-DD HH:mm:ss";
+        break;
+      case "DATE-INPUT":
+        dateType = "YYYY-MM-DD";
+        break;
+      case "TIME-INPUT":
+        dateType = "HH:mm:ss";
+        break;
+      case "DATE":
+        data.date_format = data.date_format && data.date_format.replace(/yyyy/gi, "YYYY");
+        dateType = (data.date_format || "YYYY-MM-DD").replace(/yyyy-MM-dd/gi, "YYYY-MM-DD").replace(/hh:mm:ss/gi, "HH:mm:ss").replace(/hh:mm/gi, "HH:mm");
+        break;
+      default:
+        dateType = data.date_format || "YYYY-MM-DD";
+        break;
+    }
+    return dateType;
+  }
+  function handleGetJsonStr(str) {
+    let resObj = {};
+    if (XEUtils.isJSON(str)) {
+      resObj = JSON.parse(str);
+    } else {
+      resObj = typeof str === "string" ? {} : str;
+    }
+    if (resObj && !resObj.objs && resObj.value) {
+      if (XEUtils.isJSON(resObj.value)) {
+        resObj = JSON.parse(resObj.value);
+        if (resObj.type === "jsonb") {
+          resObj = handleGetJsonStr(resObj);
+        }
+      }
+    }
+    return resObj;
+  }
+  return {
+    handleSetFieldsValue,
+    handleCheckKeyInform,
+    handleGetJsonStr,
+    handlerGetDateType,
+    transformStr,
+    handleGetTargetList
+  };
+}
+
+export { useFormCommon };

package/es/components/form-table/src/hooks/useFormEvent.d.ts

@@ -0,0 +1,9 @@
+import { AnyObject, Func } from '../../../../../es/shared/types';
+export declare function useFormEvent({ mainForm, row, userInfo }: {
+    mainForm: AnyObject;
+    row: AnyObject;
+    userInfo: AnyObject;
+}, handleSetFieldsValue: Func): {
+    handleGetOperationalKey: <T = string>(str: T) => T;
+    handleOperational: (v: AnyObject) => Promise<void>;
+};

package/es/components/form-table/src/hooks/useFormEvent.js

@@ -0,0 +1,68 @@
+import XEUtils from 'xe-utils';
+import 'moment';
+
+function useFormEvent({ mainForm, row, userInfo }, handleSetFieldsValue) {
+  async function handleOperational(v) {
+    let curKey = v.val_key;
+    const {
+      operationalForm = []
+    } = mainForm || {};
+    setTimeout(async () => {
+      var _a;
+      let formValue = row;
+      let obj = {
+        table: formValue,
+        form: formValue,
+        sys: ((_a = userInfo == null ? void 0 : userInfo.map) == null ? void 0 : _a.sysParams) || {}
+      };
+      operationalForm.forEach((v) => {
+        let itemRes;
+        let operationalRule = XEUtils.handleSysParams(v.operationalRule, obj, 0);
+        let operationFormParam = v.operationFormParam;
+        let f = operationFormParam.find((v2) => v2.includes(curKey));
+        if (!f)
+          return;
+        let operationalResult = handleGetOperationalKey(v.operationalResult);
+        let targetValueStr = "itemRes=" + operationalRule;
+        try {
+          eval(targetValueStr);
+          let operationalPrecision = +v.operationalPrecision;
+          if (typeof itemRes === "number" && !isFinite(itemRes)) {
+            itemRes = 0;
+          }
+          if (operationalPrecision && String(itemRes).includes(".")) {
+            itemRes = itemRes.toFixed(operationalPrecision);
+          }
+          console.log(itemRes, "---itemRes");
+          handleSetFieldsValue({
+            [operationalResult]: itemRes
+          });
+        } catch (error) {
+          console.log(error, "\u8BA1\u7B97\u51FA\u9519");
+        }
+      });
+    }, 16);
+  }
+  function handleGetOperationalKey(str) {
+    const getVal = (t, r) => {
+      return t.replace(r, function(...args) {
+        return args[1] || "";
+      });
+    };
+    if (typeof str === "string") {
+      if (str.includes("form.")) {
+        str = getVal(str, /form.(.*?)/g);
+      } else if (str.includes("sys.")) {
+        str = getVal(str, /sys.(.*?)/g);
+      } else if (str.includes("db.")) {
+        str = getVal(str, /db.(.*?)/g);
+      } else if (str.includes("table.")) {
+        str = getVal(str, /table.(.*?)/g);
+      }
+    }
+    return str;
+  }
+  return { handleGetOperationalKey, handleOperational };
+}
+
+export { useFormEvent };

package/es/components/form-table/src/hooks/useItemDefault.d.ts

@@ -0,0 +1,53 @@
+import { AnyObject, Func } from '../../../../../es/shared/types';
+import { MessageInstance } from '../../../../../es/components/form-table/src/types';
+export declare function useItemDefault({ message, props, emit }: {
+    message: MessageInstance;
+    props: Record<string, any>;
+    emit: Func;
+}): {
+    formTable: AnyObject;
+    hasErr: import("vue").ComputedRef<any>;
+    handleGetJsonStr: (str: string | AnyObject) => AnyObject;
+    handleSetFieldsValue: (setObj?: AnyObject, target?: any) => void;
+    handleGetUniqueKey: (id: string) => any;
+    handleSysParams: (str: string) => string;
+    defaultInit: () => void;
+    handleTableBlur: (e?: AnyObject, config?: AnyObject) => void;
+    handleFormParams: (str: string) => string;
+    radioColor: () => (p: AnyObject, isOnlyRead?: boolean) => any;
+    handleGetAgeUnit: (ageInfo?: AnyObject) => string | undefined;
+    handleAgeToBirthDay: (val: number, f: string, item: AnyObject) => void;
+    changeAgeSelect: (val: string, item: AnyObject) => void;
+    handlerSetIdCarInfoValidate: (value: any, item: AnyObject, callback: Func<any[], any>) => void;
+    getInputCheck: (validate?: string | undefined) => {
+        pattern: RegExp;
+        message: string;
+    } | undefined;
+    getCustomRegular: (item: AnyObject) => {
+        pattern: RegExp;
+        message: any;
+    } | null;
+    checkDigital: import("../../../../../es/components/form-table/src/types").ValidateFunc;
+    checkAgeJson: import("../../../../../es/components/form-table/src/types").ValidateFunc;
+    checkAge: import("../../../../../es/components/form-table/src/types").ValidateFunc;
+    checkMultipleChoice: import("../../../../../es/components/form-table/src/types").ValidateFunc;
+    checkLength: import("../../../../../es/components/form-table/src/types").ValidateFunc;
+    checkinputBlank: import("../../../../../es/components/form-table/src/types").ValidateFunc;
+    handlerGetDateType: (data: AnyObject) => any;
+    checkSearchCascade: import("../../../../../es/components/form-table/src/types").ValidateFunc;
+    checkMultipleTree: import("../../../../../es/components/form-table/src/types").ValidateFunc;
+    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]>>>;
+};