@lingxiteam/ebe-utils 0.2.4 → 0.2.6

package/lib/pcpublic/src/components/pcfactory/src/utils/generatorDisabledCallback.ts

@@ -0,0 +1,505 @@
+import moment, { Moment } from 'moment';
+import { DatePickerOptions } from './constant';
+import { getHolidaysChecker, isWorkdays } from './Holidays';
+
+const formatStr = {
+  date: 'YYYY-MM-DD',
+  time: 'YYYY-MM-DD HH:mm:ss',
+};
+
+export type DisabledDateTimeFnResult = (cur: Moment) => {
+  disabledHours: () => number[];
+  disabledMinutes: () => number[];
+  disabledSeconds: () => number[];
+};
+
+/**
+ * 限制范围类型
+ */
+export type LimitRangeType = (typeof DatePickerOptions.limitRangeOptions)[number]['value'];
+
+/**
+ * 节假日类型
+ */
+export type HolidaysLimitType = (typeof DatePickerOptions.holidaysLimitOptions)[number]['value'];
+export interface IGeneratorParams {
+
+  /**
+   * 限制类型
+   */
+  limitRange: LimitRangeType;
+
+  /**
+   * 日期模式
+   */
+  timeMode: 'time' | 'date';
+
+  /**
+   * 开始时间 limitRange => period
+   */
+  startDate?: string;
+
+  /**
+   * 截止时间 limitRange => period
+   */
+  endDate?: string;
+
+  /**
+   * 指定时间 limitRange => beforeSelect | afterSelect
+   */
+  selectTime?: string;
+
+  /**
+   * 可选时间 limitRange => multipleSelect
+   */
+  validMultiDate?: string[];
+
+  /**
+   * 节假日限制
+   */
+  holidaysLimit: HolidaysLimitType;
+}
+
+/**
+ * 根据配置获取有效日期
+ * @param str runtime | 具体日期 | add:[1day] | subtract:[1day]
+ * @returns
+ */
+const getRelDate = (str: string): Moment | null => {
+  if (str === 'runtime') {
+    return moment();
+  }
+  if (str.startsWith('runtime:[00:00:00]')) {
+    return moment().startOf('day');
+  }
+  if (str.startsWith('runtime:[23:59:59]')) {
+    return moment().endOf('day');
+  }
+  if (moment(str).isValid()) {
+    return moment(str);
+  }
+  return null;
+};
+
+/**
+ * 获取相对日期
+ * @param dateStr add:[*]  subtract:[*]
+ * @param refDate 相对日期
+ */
+export const getPeriodDate = (dateStr: string, refDate: Moment = moment()): Moment => {
+  const fn = dateStr.startsWith('add') ? 'add' : 'subtract';
+  const refStr = dateStr.replace(`${fn}:[`, '').slice(0, -1);
+  const amount = Number(refStr.replace(/\D+/, ''));
+  const unit: any = refStr.replace(/\d+/, '');
+  return refDate[fn](amount, unit);
+};
+
+export interface GeneratorDisabledCallbackResultType {
+
+  /**
+   * 日期禁用校验方法
+   * @param cur 当前时间
+   * @param taday
+   * @returns
+   */
+  disabledDateFn: (cur: Moment, taday?: Moment) => boolean;
+
+  /**
+   * 时间禁用校验方法
+   * @param cur 当前时间
+   * @returns
+   */
+  disabledDateTimeFn: null | DisabledDateTimeFnResult;
+
+  /**
+   * 开始时间
+   */
+  startDate?: Moment;
+
+  /**
+   * ]截止时间
+   */
+  endDate?: Moment;
+}
+
+const getInfoFromMoment = (cur?: Moment): [string, number, number, number] => {
+  return cur ? [cur?.format(formatStr.date), cur?.get('hours'), cur?.get('minutes'), cur?.get('seconds')] : ['', 0, 0, 0];
+};
+
+/**
+ * 时间禁用函数生成
+ * @param startDate 开启时间
+ * @param endDate 结束时间
+ * @returns
+ */
+const generatorDisabledDateTimeFn = (startDate?: Moment, endDate?: Moment): null | DisabledDateTimeFnResult => {
+  if (!startDate && !endDate) {
+    return null;
+  }
+
+  startDate?.get('hours');
+  const [startDateStr, startHour, startMinute, startSecond] = getInfoFromMoment(startDate);
+  const [endDateStr, endHour, endMinute, endSecond] = getInfoFromMoment(endDate);
+
+  return cur => {
+    const [currentDateStr, currentHour, currentMinute] = getInfoFromMoment(cur);
+    // 起始日期
+    if (startDateStr === currentDateStr) {
+      // 如果当前小时大于开始小时
+      if (currentHour > startHour) {
+        return {
+          disabledHours: () => (startHour ? [...Array(startHour).keys()] : []), // 如果当前日期和startTime相同，禁止选择startTime之前的小时
+          disabledMinutes: () => [],
+          disabledSeconds: () => [],
+        };
+        // 如果当前小时等于开始小时，且当前分钟大于开始分钟
+      }
+      if (currentHour === startHour) {
+        if (currentMinute > startMinute) {
+          return {
+            disabledHours: () => (startHour ? [...Array(startHour).keys()] : []), // 如果当前日期和startTime相同，禁止选择startTime之前的小时
+            disabledMinutes: () => (startMinute ? [...Array(startMinute).keys()] : []), // 如果当前日期和startTime相同，禁止选择startTime之前的分钟
+            disabledSeconds: () => [],
+          };
+        }
+      }
+      // 否则就按照开始时间的小时、分钟、秒钟来禁用
+      return {
+        disabledHours: () => (startHour ? [...Array(startHour).keys()] : []), // 如果当前日期和startTime相同，禁止选择startTime之前的小时
+        disabledMinutes: () => (startMinute ? [...Array(startMinute).keys()] : []), // 如果当前日期和startTime相同，禁止选择startTime之前的分钟
+        disabledSeconds: () => (startSecond ? [...Array(startSecond).keys()] : []), // 如果当前日期和startTime相同，禁止选择startTime之前的秒钟
+      };
+    }
+
+    // 结束日期
+    if (endDateStr === currentDateStr) {
+      // 当前小时小于结束小时
+      if (currentHour < endHour) {
+        return {
+          disabledHours: () => (endHour ? [...Array(24 - endHour - 1).keys()].map(h => h + endHour + 1) : []), // 如果当前日期和endTime相同，禁止选择endTime之后的小时
+          disabledMinutes: () => [],
+          disabledSeconds: () => [],
+        };
+        // 当当前小时等于结束小时，且当前分钟小于结束分钟
+      }
+      if (currentHour === endHour) {
+        if (currentMinute < endMinute) {
+          return {
+            disabledHours: () => (endHour ? [...Array(24 - endHour - 1).keys()].map(h => h + endHour + 1) : []), // 如果当前日期和endTime相同，禁止选择endTime之后的小时
+            disabledMinutes: () => (endMinute ? [...Array(60 - endMinute - 1).keys()].map(m => m + endMinute + 1) : []), // 如果当前日期和endTime相同，禁止选择endTime之后的分钟
+            disabledSeconds: () => [],
+          };
+        }
+      }
+      return {
+        disabledHours: () => (endHour ? [...Array(24 - endHour - 1).keys()].map(h => h + endHour + 1) : []), // 如果当前日期和endTime相同，禁止选择endTime之后的小时
+        disabledMinutes: () => (endMinute ? [...Array(60 - endMinute - 1).keys()].map(m => m + endMinute + 1) : []), // 如果当前日期和endTime相同，禁止选择endTime之后的分钟
+        disabledSeconds: () => (endSecond ? [...Array(60 - endSecond - 1).keys()].map(s => s + endSecond + 1) : []), // 如果当前日期和endTime相同，禁止选择endTime之后的秒钟
+      };
+    }
+
+    return {
+      disabledHours: () => [],
+      disabledMinutes: () => [],
+      disabledSeconds: () => [],
+    };
+  };
+};
+
+/**
+ * 根据传入的规则生成 日期禁用回调函数
+ * @param params 入参
+ * @returns
+ */
+export const generatorDisabledCallback = (params: IGeneratorParams): GeneratorDisabledCallbackResultType => {
+  const { holidaysLimit = 'no', limitRange, selectTime, startDate, endDate, validMultiDate, timeMode } = params;
+
+  /**
+   * 所选日期
+   */
+  const selectDateMoment = moment(selectTime);
+
+  /**
+   * 运行时间
+   */
+  const runtimeMoment = moment();
+
+  const { isHolidayLimit } = getHolidaysChecker(holidaysLimit);
+
+  const isTimeMode = timeMode === 'time';
+
+  /**
+   * 包裹节假日判断
+   * @param cb
+   * @returns
+   */
+  const wrapperFn = (cb: (cur: Moment) => boolean) => {
+    return (cur: Moment) => {
+      if (isHolidayLimit(cur)) {
+        return true;
+      }
+      return cb(cur);
+    };
+  };
+
+  /**
+   * 无限制方法
+   */
+  const unlimitedFn = wrapperFn(() => false);
+
+  /**
+   * 默认方法
+   */
+  const defaultResult: GeneratorDisabledCallbackResultType = {
+    disabledDateFn: unlimitedFn,
+    disabledDateTimeFn: null,
+  };
+
+  let nextFlag = false;
+  // 根据配置获取有效区间
+  let start: Moment | null = null;
+  let end: Moment | null = null;
+
+  switch (limitRange) {
+    case 'no':
+    case undefined:
+      defaultResult.disabledDateFn = unlimitedFn;
+      break;
+    // 指定日期前后
+    case 'beforeSelect':
+    case 'afterSelect': {
+      if (limitRange === 'beforeSelect') {
+        end = selectDateMoment.isValid() ? selectDateMoment : null;
+      } else {
+        start = selectDateMoment.isValid() ? selectDateMoment : null;
+      }
+      defaultResult.disabledDateFn =
+        selectTime && selectDateMoment.isValid()
+          ? wrapperFn(cur => {
+            return limitRange === 'beforeSelect' ? cur.isAfter(selectDateMoment) : cur.isBefore(selectDateMoment);
+          })
+          : unlimitedFn;
+      break;
+    }
+    case 'beforeToday':
+    case 'afterToday': {
+      if (limitRange === 'beforeToday') {
+        end = isTimeMode ? runtimeMoment.clone() : runtimeMoment.clone().endOf('days');
+      } else {
+        start = isTimeMode ? runtimeMoment.clone() : runtimeMoment.clone().startOf('days');
+      }
+      defaultResult.disabledDateFn = wrapperFn(cur => {
+        return limitRange === 'beforeToday' ? cur.isAfter(runtimeMoment.clone().endOf('days')) : cur.isBefore(runtimeMoment.clone().startOf('days'));
+      });
+      break;
+    }
+    case 'multipleSelect':
+      defaultResult.disabledDateFn = validMultiDate?.length
+        ? wrapperFn(cur => {
+          const curStr = cur.format(formatStr.date);
+          return !validMultiDate.includes(curStr);
+        })
+        : unlimitedFn;
+      break;
+    default:
+      nextFlag = true;
+      break;
+  }
+
+  if (!nextFlag) {
+    defaultResult.disabledDateTimeFn = generatorDisabledDateTimeFn(start || undefined, end || undefined);
+    return defaultResult;
+  }
+
+  let cursorMoment = moment();
+  // 根据配置获取有效区间
+  start = moment();
+  end = moment();
+
+  /**
+   * 收集需要动态禁用的日期
+   */
+  const dynamicDisabledDate: string[] = [];
+
+  if (limitRange?.startsWith('range:[')) {
+    const types = limitRange.replace('range:[', '').slice(0, -1).split(',');
+    const [startStr, endStr] = types;
+    if (startStr !== endStr) {
+      const dynamicStr = startStr === 'runtime' ? endStr : startStr;
+      const leng = Number(dynamicStr.replace(/\D+/, ''));
+      const unit = dynamicStr.replace(/\d+/, '');
+
+      const fnType = startStr === 'runtime' ? 'add' : 'subtract';
+
+      // 工作日需要特殊处理
+      if (unit === 'workdays') {
+        let curLength = leng;
+        while (curLength) {
+          cursorMoment = cursorMoment[fnType](1, 'days');
+          if (isWorkdays(cursorMoment)) {
+            curLength -= 1;
+          } else {
+            dynamicDisabledDate.push(cursorMoment.format(formatStr.date));
+          }
+        }
+      } else {
+        cursorMoment[fnType](leng, unit as any);
+      }
+      // 起止时间设置
+      if (startStr === 'runtime') {
+        end = cursorMoment;
+      } else {
+        start = cursorMoment;
+      }
+    }
+  }
+  // 区间选择
+  if (limitRange === 'period') {
+    if (startDate && endDate) {
+      const tmpStart = getRelDate(startDate);
+      const tmpEnd = getRelDate(endDate);
+      // 正常配置下 有且仅有一个日期为动态值
+      if ([tmpStart, tmpEnd].filter(el => el === null).length <= 1) {
+        start = tmpStart || getPeriodDate(startDate, tmpEnd?.clone());
+        end = tmpEnd || getPeriodDate(endDate, tmpStart?.clone());
+      }
+    }
+  }
+  defaultResult.startDate = start;
+  defaultResult.endDate = end;
+  if (timeMode === 'time') {
+    defaultResult.disabledDateTimeFn = generatorDisabledDateTimeFn(start, end);
+  }
+
+  defaultResult.disabledDateFn = wrapperFn(cur => {
+    const curStr = cur.format(formatStr.date);
+    if (dynamicDisabledDate.includes(curStr)) {
+      return true;
+    }
+    return !(cur.isBetween(start, end) || start?.isSame(cur, 'date') || end?.isSame(cur, 'date'));
+  });
+
+  return defaultResult;
+};
+
+export interface RuleCallbackProps extends GeneratorDisabledCallbackResultType {
+
+  /**
+   * 日期格式
+   */
+  tiemMode: string;
+
+  /**
+   * 当前选中值
+   */
+  currentValue: string | Moment;
+
+  /**
+   * 节假日限制
+   */
+  holidaysLimit: HolidaysLimitType;
+
+  /**
+   * 获取提示内容
+   * @param t
+   * @param params
+   * @returns
+   */
+  getLocale: (t: string, params?: any) => any;
+
+  /**
+   * 控件名称
+   */
+  name: string;
+
+  /**
+   * 日期格式化
+   */
+  format: string;
+}
+
+export const getRuleCallback = (props: RuleCallbackProps): string => {
+  const { disabledDateFn, tiemMode, startDate, currentValue, endDate, holidaysLimit, getLocale, name, format } = props;
+
+  const isArray = Array.isArray(currentValue) && currentValue.length === 2;
+
+  const currentStart = moment(isArray ? currentValue[0] : currentValue, format);
+  const currentEnd = moment(isArray ? currentValue[1] : currentValue, format);
+
+  if (startDate && endDate && startDate <= endDate && (disabledDateFn(currentStart) || disabledDateFn(currentEnd))) {
+    return getLocale('DatePicker.period', {
+      name,
+      startTime: startDate.format(tiemMode === 'time' ? formatStr.time : formatStr.date),
+      endTime: endDate.format(tiemMode === 'time' ? formatStr.time : formatStr.date),
+    });
+  }
+  const list = [
+    startDate
+      ? {
+        min: currentStart,
+        max: startDate,
+        type: 'DatePicker.after',
+      }
+      : null,
+    startDate
+      ? {
+        min: currentEnd,
+        max: startDate,
+        type: 'DatePicker.after',
+      }
+      : null,
+    endDate
+      ? {
+        min: endDate,
+        max: currentStart,
+        type: 'DatePicker.before',
+      }
+      : null,
+    endDate
+      ? {
+        min: endDate,
+        max: currentEnd,
+        type: 'DatePicker.before',
+      }
+      : null,
+  ].filter(el => !!el);
+  for (let i = 0; i < list.length; i += 1) {
+    const item = list[i];
+    if (item && item.min < item.max) {
+      return getLocale(item.type, {
+        name,
+        [`${item.type === 'DatePicker.after' ? 'startTime' : 'endTime'}`]: (item.type === 'DatePicker.after' ? item.max : item.min).format(
+          tiemMode === 'time' ? formatStr.time : formatStr.date
+        ),
+      });
+    }
+  }
+  // 节假日校验
+  if (isArray && holidaysLimit !== 'no' && currentStart < currentEnd) {
+    const tmpStart = currentStart.clone();
+
+    const returnStr = () => {
+      const type = `DatePicker.holidaysLimit.${holidaysLimit}`;
+      return getLocale(type, {
+        name,
+      });
+    };
+
+    const { isHolidayLimit } = getHolidaysChecker(holidaysLimit);
+    let diff = currentEnd.diff(currentStart, 'days');
+    let flag = false;
+    while (diff > 0) {
+      tmpStart.add(1, 'days');
+      if (isHolidayLimit(tmpStart)) {
+        flag = true;
+        break;
+      }
+      diff -= 1;
+    }
+    // 所选日期包含节假日限制
+    if (flag) {
+      return returnStr();
+    }
+  }
+  return '';
+};

package/lib/pcpublic/src/components/pcfactory/src/utils/getExportDefaultObj.ts

@@ -1,9 +1,6 @@
 export const getExportDefaultObj = (obj: any) => {
   if (typeof obj === 'object') {
-    if (
-      obj.__esModule === true &&
-      Object.prototype.hasOwnProperty.call(obj, 'default')
-    ) {
+    if (obj.__esModule === true && Object.prototype.hasOwnProperty.call(obj, 'default')) {
       return obj.default;
     }
   }

package/lib/pcpublic/src/components/pcfactory/src/utils/hooks/useCommonImperativeHandle.ts

@@ -3,7 +3,7 @@ import { MonitorFn, useForm } from '../formUtils/FormContext';
 import { FormFieldsHooks } from '../formUtils/FormFields';
 import { useListenProps } from './useListenState';
 import { useLocale } from './useLocale';
-import useRules, { RuleInterface } from './useRules';
+import useRules, { createEmptyRule, RuleInterface } from './useRules';
 
 /**
  *
@@ -11,17 +11,8 @@ import useRules, { RuleInterface } from './useRules';
  * @param handle 额外的方法
  * @param depends 依赖监听
  */
-export const useCommonImperativeHandle = (
-  ref: any,
-  props: any,
-  handle: any = {},
-) => {
-  const {
-    disabled: propsDisabled,
-    required: propsRequired,
-    readOnly: propsReadOnly,
-    getEngineApis,
-  } = props;
+export const useCommonImperativeHandle = (ref: any, props: any, handle: any = {}) => {
+  const { disabled: propsDisabled, required: propsRequired, readOnly: propsReadOnly, getEngineApis, fieldName } = props;
 
   const engineApis = getEngineApis();
 
@@ -40,7 +31,7 @@ export const useCommonImperativeHandle = (
   const { getLocale, lang } = useLocale(engineApis);
 
   // 通用规则生成
-  const [finalRules, setExtendRules] = useRules(
+  const [finalRules, setExtendRules, setFinialRules] = useRules(
     {
       required,
       regexp: props.regexp,
@@ -49,7 +40,7 @@ export const useCommonImperativeHandle = (
       name: props.name,
     },
     getLocale,
-    lang,
+    lang
   );
 
   const clearValue = () => {
@@ -99,12 +90,21 @@ export const useCommonImperativeHandle = (
      * @param newRules
      * @param isAppendLastTime 是否累计上一次的
      */
-    appendRules: (
-      newRules: RuleInterface[],
-      isAppendLastTime: boolean = true,
-    ) => {
+    appendRules: (newRules: RuleInterface[], isAppendLastTime: boolean = true) => {
       setExtendRules(newRules, isAppendLastTime);
     },
+
+    /**
+     * 清空rules
+     */
+    clearRules: () => {
+      // FIXME: 为了规避rc-form-field的校验bug 具体代码可以参考rc-form-field/src/useForm.ts#904，
+      // 如果把rules直接设置为空之后，该规则将不再进行校验。导致一直存在错误的信息展示。
+      setFinialRules([createEmptyRule()]);
+      if (formContext.inForm) {
+        formContext.form.validateFields([fieldName]);
+      }
+    },
   }));
 
   /**

package/lib/pcpublic/src/components/pcfactory/src/utils/hooks/useCompState.tsx

@@ -3,12 +3,7 @@ import { useMemo } from 'react';
 export const renderHTML = (des: string) => {
   if (des) {
     // eslint-disable-next-line react/no-danger
-    return (
-      <span
-        dangerouslySetInnerHTML={{ __html: des }}
-        style={{ display: 'flex', justifyContent: 'center' }}
-      />
-    );
+    return <span dangerouslySetInnerHTML={{ __html: des }} style={{ display: 'flex', justifyContent: 'center' }} />;
   }
   return null;
 };
@@ -23,10 +18,7 @@ const useCompState = (props: CompStateProps) => {
   const { dataState, type, tip } = props;
   const state = useMemo(() => dataState?.[type], [dataState?.[type]]);
 
-  const stateTip = useMemo(
-    () => renderHTML(tip || state?.tip),
-    [state?.tip, tip],
-  );
+  const stateTip = useMemo(() => renderHTML(tip || state?.tip), [state?.tip, tip]);
 
   const stateIcon = useMemo(() => {
     if (state?.iconIsCustom && state?.icon) {

package/lib/pcpublic/src/components/pcfactory/src/utils/hooks/useDataMask.ts

@@ -24,35 +24,29 @@ export const useDataMask = ({
     maskValue: any;
     getMaskData(value: any): any;
     init: boolean;
-  }>(() => {
-    const { functorsMap } = getEngineApis() || {};
-    if (!functorsMap?.DATAMASK || !dataMask) {
-      return {
-        isMask: false,
-        defaultMaskValue: defaultValue,
-        maskValue: value,
-        getMaskData: (val) => val,
-        init: false,
-      };
-    }
+      }>(() => {
+        const { functorsMap } = getEngineApis() || {};
+        if (!functorsMap?.DATAMASK || !dataMask) {
+          return {
+            isMask: false,
+            defaultMaskValue: defaultValue,
+            maskValue: value,
+            getMaskData: val => val,
+            init: false,
+          };
+        }
 
-    const defaultMaskValue =
-      defaultValue !== undefined
-        ? functorsMap.DATAMASK(defaultValue || '', dataMask)
-        : defaultValue;
-    return {
-      isMask: true,
-      defaultMaskValue,
-      maskValue:
-        value !== undefined
-          ? functorsMap.DATAMASK(value || '', dataMask)
-          : defaultMaskValue,
-      getMaskData(value) {
-        return functorsMap.DATAMASK(value, dataMask);
-      },
-      init: false,
-    };
-  }, []);
+        const defaultMaskValue = defaultValue !== undefined ? functorsMap.DATAMASK(defaultValue || '', dataMask) : defaultValue;
+        return {
+          isMask: true,
+          defaultMaskValue,
+          maskValue: value !== undefined ? functorsMap.DATAMASK(value || '', dataMask) : defaultMaskValue,
+          getMaskData(value) {
+            return functorsMap.DATAMASK(value, dataMask);
+          },
+          init: false,
+        };
+      }, []);
 
   const maskValue = useMemo(() => {
     if (maskData.isMask) {
@@ -74,9 +68,7 @@ export const useDataMask = ({
       maskData.isMask = false;
     },
     maskValue: !maskData.isMask ? value : maskValue,
-    defaultMaskValue: !maskData.isMask
-      ? defaultValue
-      : maskData.defaultMaskValue,
+    defaultMaskValue: !maskData.isMask ? defaultValue : maskData.defaultMaskValue,
   };
 };