@lingxiteam/ebe-utils 0.5.11 → 0.6.1

package/lib/h5public/src/components/factory/src/utils/DateUtils/generatorDisabledCallback.ts

@@ -0,0 +1,516 @@
+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);
+  } else {
+    start.startOf('days');
+    end.endOf('days');
+  }
+
+  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/h5public/src/components/factory/src/utils/LoaderHelper.tsx

@@ -7,7 +7,9 @@ import Loadable from 'react-loadable';
  */
 export const LoadingComponennt = (props: any) => {
   // console.log("加载中组件", props);
-  return <></>;
+  return (
+    <></>
+  );
 };
 
 const loaderHelper = (loaderRet: any, loading = LoadingComponennt) => {

package/lib/h5public/src/components/factory/src/utils/PropType.ts

@@ -15,7 +15,9 @@ export type FilterWhiteSpace<T extends Record<string, any>> = {
   [Key in RecordKeys<T>]: T[Key] extends undefined ? never : T[Key];
 };
 
-export type FilterWhiteSpaceFunction<T extends FilterWhiteSpaceParamaters> = (params: T) => FilterWhiteSpaceParamaters;
+export type FilterWhiteSpaceFunction<T extends FilterWhiteSpaceParamaters> = (
+  params: T,
+) => FilterWhiteSpaceParamaters;
 
 export interface GetRulesParamaters {
   required?: boolean;

package/lib/h5public/src/components/factory/src/utils/ahooks/index.ts

@@ -1,10 +1,12 @@
-import useCreation from './useCreation';
-import { useDeepCompareEffect } from './useDeepCompareEffect';
-import useMemoizedFn from './useMemoizedFn';
 import usePrevious from './usePrevious';
 import useSafeState from './useSafeState';
-import useSetState, { SetState } from './useSetState';
+import useMemoizedFn from './useMemoizedFn';
 import useUpdateEffect from './useUpdateEffect';
+import { useDeepCompareEffect } from './useDeepCompareEffect';
+import useSetState, { SetState } from './useSetState';
+import useCreation from './useCreation';
 
-export type { SetState };
+export type {
+  SetState,
+};
 export { usePrevious, useSafeState, useMemoizedFn, useUpdateEffect, useDeepCompareEffect, useSetState, useCreation };

package/lib/h5public/src/components/factory/src/utils/ahooks/useMemoizedFn.ts

@@ -2,7 +2,10 @@ import { useMemo, useRef } from 'react';
 
 type noop = (this: any, ...args: any[]) => any;
 
-type PickFunction<T extends noop> = (this: ThisParameterType<T>, ...args: Parameters<T>) => ReturnType<T>;
+type PickFunction<T extends noop> = (
+  this: ThisParameterType<T>,
+  ...args: Parameters<T>
+) => ReturnType<T>;
 
 function useMemoizedFn<T extends noop>(fn: T) {
   const fnRef = useRef<T>(fn);

package/lib/h5public/src/components/factory/src/utils/ahooks/useSafeState.ts

@@ -1,5 +1,5 @@
-import type { Dispatch, SetStateAction } from 'react';
 import { useCallback, useState } from 'react';
+import type { Dispatch, SetStateAction } from 'react';
 import useUnmountedRef from './useUnmountedRef';
 
 function useSafeState<S>(initialState: S | (() => S)): [S, Dispatch<SetStateAction<S>>];
@@ -9,7 +9,7 @@ function useSafeState<S = undefined>(): [S | undefined, Dispatch<SetStateAction<
 function useSafeState<S>(initialState?: S | (() => S)) {
   const unmountedRef = useUnmountedRef();
   const [state, setState] = useState(initialState);
-  const setCurrentState = useCallback(currentState => {
+  const setCurrentState = useCallback((currentState) => {
     /** if component is unmounted, stop update */
     if (unmountedRef.current) return;
     setState(currentState);

package/lib/h5public/src/components/factory/src/utils/ahooks/useSetState.ts

@@ -1,15 +1,17 @@
-import isFunction from 'lodash/isFunction';
 import { useCallback, useState } from 'react';
+import isFunction from 'lodash/isFunction';
 
 export type SetState<S extends Record<string, any>> = <K extends keyof S>(
-  state: Pick<S, K> | null | ((prevState: Readonly<S>) => Pick<S, K> | S | null)
+  state: Pick<S, K> | null | ((prevState: Readonly<S>) => Pick<S, K> | S | null),
 ) => void;
 
-const useSetState = <S extends Record<string, any>>(initialState: S | (() => S)): [S, SetState<S>] => {
+const useSetState = <S extends Record<string, any>>(
+  initialState: S | (() => S),
+): [S, SetState<S>] => {
   const [state, setState] = useState<S>(initialState);
 
-  const setMergeState = useCallback(patch => {
-    setState(prevState => {
+  const setMergeState = useCallback((patch) => {
+    setState((prevState) => {
       const newState = isFunction(patch) ? patch(prevState) : patch;
       return newState ? { ...prevState, ...newState } : prevState;
     });

package/lib/h5public/src/components/factory/src/utils/checkFileType.ts

@@ -0,0 +1,79 @@
+import { Toast } from 'antd-mobile-5';
+
+const getImgType = (file: File) => {
+  let fileType = file?.type;
+  if (
+    (!fileType || fileType.length === 0) &&
+    (file?.name?.includes('.HEIC') || file?.name?.includes('.heic'))
+  ) {
+    fileType = 'image/heic';
+  }
+  const targetType = fileType.split('image/')[1];
+  let targetFileType = targetType;
+  // .ico 图片类型需要特殊处理
+  if (['vnd.microsoft.icon', 'x-icon'].includes(targetType)) {
+    targetFileType = 'ico';
+  }
+  return targetFileType;
+};
+
+/**
+ * 校验文件类型
+ * @param file
+ * @returns
+ */
+export const checkFileType = (file: File, acceptStr: string) => {
+  if (acceptStr && acceptStr?.startsWith('.')) {
+    // 自定义图片类型
+    const { name = '' } = file;
+    const targetType = getImgType(file);
+    // 兼容Window 下heic获取到图片格式为为空
+    let msg;
+    if (targetType) {
+      msg = targetType;
+    } else if (name) {
+      msg = name.split('.').pop();
+    }
+    if (acceptStr.indexOf(`.${targetType}`) > -1) {
+      return true;
+    }
+    const content = msg ? `不支持上传 .${msg} 图片` : '不支持上传该类型图片';
+    Toast.show({
+      icon: 'fail',
+      content,
+    });
+    return false;
+  }
+  return true;
+};
+
+/**
+ * 获取图片上传的格式
+ * @returns
+ */
+export const getAcceptTargetValue = (uploadAccepType: any) => {
+  const { accept, acceptExtension } = uploadAccepType || {};
+  let targetacceptExtension = '';
+  if (acceptExtension) {
+    const extensionList = acceptExtension.split(',');
+    if (extensionList && extensionList.length > 0) {
+      targetacceptExtension = extensionList
+        .map((item: string) => {
+          if (item.startsWith('.')) {
+            return item;
+          }
+          return `.${item}`;
+        })
+        .join(',');
+    }
+  }
+  let combinedAcceptType;
+  if (accept && targetacceptExtension) {
+    combinedAcceptType = `${accept},${targetacceptExtension}`;
+  } else if (accept) {
+    combinedAcceptType = accept;
+  } else if (targetacceptExtension) {
+    combinedAcceptType = targetacceptExtension;
+  }
+  return combinedAcceptType;
+};