@lingxiteam/ebe-utils 0.2.21 → 0.2.23

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

@@ -0,0 +1,83 @@
+
+// 该文件由  scripts/generatorHolidays.js 动态生成 请勿手动修改
+    
+/**
+ * 工作日
+ */
+export const workdays = [
+  '2024-10-12',
+  '2024-09-29',
+  '2024-09-14',
+  '2024-05-11',
+  '2024-04-28',
+  '2024-04-07',
+  '2024-02-18',
+  '2024-02-04',
+  '2025-01-26',
+  '2025-02-08',
+  '2025-04-27',
+  '2025-09-28',
+  '2025-10-11',
+];
+
+/**
+ * 节假日
+ */
+export const holidays = [
+  '2024-10-07',
+  '2024-10-06',
+  '2024-10-05',
+  '2024-10-04',
+  '2024-10-03',
+  '2024-10-02',
+  '2024-10-01',
+  '2024-09-17',
+  '2024-09-16',
+  '2024-09-15',
+  '2024-06-10',
+  '2024-05-05',
+  '2024-05-04',
+  '2024-05-03',
+  '2024-05-02',
+  '2024-05-01',
+  '2024-04-06',
+  '2024-04-05',
+  '2024-04-04',
+  '2024-02-17',
+  '2024-02-16',
+  '2024-02-15',
+  '2024-02-14',
+  '2024-02-13',
+  '2024-02-12',
+  '2024-02-11',
+  '2024-02-10',
+  '2024-01-01',
+  '2025-01-01',
+  '2025-02-04',
+  '2025-02-03',
+  '2025-02-02',
+  '2025-02-01',
+  '2025-01-31',
+  '2025-01-30',
+  '2025-01-29',
+  '2025-01-28',
+  '2025-04-06',
+  '2025-04-05',
+  '2025-04-04',
+  '2025-05-05',
+  '2025-05-04',
+  '2025-05-03',
+  '2025-05-02',
+  '2025-05-01',
+  '2025-06-02',
+  '2025-06-01',
+  '2025-05-31',
+  '2025-10-08',
+  '2025-10-07',
+  '2025-10-06',
+  '2025-10-05',
+  '2025-10-04',
+  '2025-10-03',
+  '2025-10-02',
+  '2025-10-01',
+];

package/lib/pcpublic/src/components/pcfactory/src/utils/IdleContainer/index.tsx

@@ -0,0 +1,47 @@
+import React, { useEffect, useState } from 'react';
+import { requestHostCallback } from './scheduler';
+import { Spin } from 'antd';
+
+const isIE = !!((window as any).ActiveXObject || 'ActiveXObject' in window);
+
+export interface IdleContainerProps {
+
+  /**
+   * 仅在 IE 浏览器下才生效，默认 true
+   */
+  onlyIE?: boolean;
+
+  /**
+   * 加载中动画
+   * @returns
+   */
+  loading?: () => React.ReactNode;
+}
+
+const IdleContainer: React.FC<IdleContainerProps> = props => {
+  const { onlyIE = true, loading = () => <Spin /> } = props;
+  const [renderChild, setRenderChild] = useState(false);
+
+  useEffect(() => {
+    if (!isIE && onlyIE) return () => { };
+
+    const cancelIdle = requestHostCallback(() => {
+      setRenderChild(true);
+    });
+    return () => {
+      cancelIdle();
+    };
+  }, []);
+
+  if (!isIE && onlyIE) {
+    return <>{props.children}</>;
+  }
+
+  if (!renderChild) {
+    return <>{loading()}</>;
+  }
+
+  return <>{props.children}</>;
+};
+
+export default IdleContainer;

package/lib/pcpublic/src/components/pcfactory/src/utils/IdleContainer/scheduler.ts

@@ -0,0 +1,74 @@
+// eslint-disable-next-line import/no-mutable-exports
+let requestHostCallback: (cb: () => void) => () => void = cb => { cb(); return () => { }; };
+
+export function isNative(Ctor: any): boolean {
+  return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+}
+
+if (
+  typeof MessageChannel !== 'undefined' &&
+  (isNative(MessageChannel) ||
+    // PhantomJS
+    MessageChannel.toString() === '[object MessageChannelConstructor]')
+) {
+  requestHostCallback = (cb: () => void) => {
+    let scheduledHostCallback: typeof cb | null = cb;
+    let isMessageLoopRunning = false;
+
+    const performWorkUntilDeadline = () => {
+      if (scheduledHostCallback !== null) {
+        try {
+          scheduledHostCallback();
+          isMessageLoopRunning = false;
+        } catch (error) {
+          port.postMessage(null);
+        }
+      } else {
+        isMessageLoopRunning = false;
+      }
+    };
+
+    const channel = new MessageChannel();
+    const port = channel.port2;
+    channel.port1.onmessage = performWorkUntilDeadline;
+
+    port.postMessage(null);
+    if (!isMessageLoopRunning) {
+      isMessageLoopRunning = true;
+      port.postMessage(null);
+    }
+
+    return () => {
+      scheduledHostCallback = null;
+    };
+  };
+} else if (typeof Promise !== 'undefined' && isNative(Promise)) {
+  requestHostCallback = (cb: () => void) => {
+    let scheduledHostCallback: typeof cb | null = cb;
+    let isMessageLoopRunning = false;
+    const p = Promise.resolve();
+
+    const performWorkUntilDeadline = () => {
+      if (scheduledHostCallback !== null) {
+        try {
+          scheduledHostCallback();
+          isMessageLoopRunning = false;
+        // eslint-disable-next-line no-empty
+        } catch (error) {}
+      } else {
+        isMessageLoopRunning = false;
+      }
+    };
+
+    if (!isMessageLoopRunning) {
+      isMessageLoopRunning = true;
+      p.then(performWorkUntilDeadline);
+    }
+
+    return () => {
+      scheduledHostCallback = null;
+    };
+  };
+}
+
+export { requestHostCallback };

package/lib/pcpublic/src/components/pcfactory/src/utils/LoaderHelper.tsx

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

package/lib/pcpublic/src/components/pcfactory/src/utils/Spin/index.tsx

@@ -1,5 +1,5 @@
+import React, { useMemo } from 'react';
 import { Spin } from 'antd';
-import { useMemo } from 'react';
 import useCompState from '../hooks/useCompState';
 
 interface SpinProps {
@@ -9,11 +9,7 @@ interface SpinProps {
 
 const SpinComp = (props: SpinProps) => {
   const { dataState, tip } = props;
-  const { stateIcon, stateTip } = useCompState({
-    dataState,
-    tip,
-    type: 'loading',
-  });
+  const { stateIcon, stateTip } = useCompState({ dataState, tip, type: 'loading' });
 
   const spinProps = useMemo(() => {
     const _spinProps: any = {};
@@ -23,7 +19,12 @@ const SpinComp = (props: SpinProps) => {
     return _spinProps;
   }, [stateIcon]);
 
-  return <Spin {...spinProps} tip={stateTip} />;
+  return (
+    <Spin
+      {...spinProps}
+      tip={stateTip}
+    />
+  );
 };
 
 export default SpinComp;

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

@@ -23,9 +23,7 @@ export interface SyncValueProps {
 // 该方法移出SyncValue，避免实际运行时创建过多闭包
 const equalsObj = (oldData: any, newData: any) => {
   // 如果其中一边的运算数是undefined，那么不要去跑原型处理等后续方法，可能提高些许性能
-  if (oldData === undefined || newData === undefined) {
-    return oldData === newData;
-  }
+  if (oldData === undefined || newData === undefined) return oldData === newData;
   // 类型为基本类型时,如果相同,则返回true
   if (oldData === newData) return true;
   if (
@@ -71,11 +69,11 @@ const SyncValue = forwardRef((props: SyncValueProps) => {
   const form = useDummyFormContext();
   const fieldName = useMemo(() => {
     if (!form?.fieldCompIdMap) return '';
-    return (Object.values(form?.fieldCompIdMap || {}) as any).find((o: any) => o.compId === compId)?.fieldName;
+    return (Object.values(form?.fieldCompIdMap || {}) as any).find((o:any) => o.compId === compId)?.fieldName;
   }, [compId]);
   const defaultValue = useMemo(() => {
     if (!form?.defaultArr) return '';
-    return (form?.defaultArr || ([] as any)).find((o: any) => o.compId === compId)?.value;
+    return (form?.defaultArr || [] as any).find((o:any) => o.compId === compId)?.value;
   }, [compId]);
 
   useEffect(() => {
@@ -98,8 +96,7 @@ const SyncValue = forwardRef((props: SyncValueProps) => {
     });
   }
   const finalMask = form?.dataMaskInst?.[fieldName] ?? isMask?.current;
-  if (finalMask && dataMaskUtil) {
-    // 脱敏值
+  if (finalMask && dataMaskUtil) { // 脱敏值
     finalvalue = dataMaskUtil.processDataMaskValue(finalvalue, finalMask);
   }
   // 把null值在此处拦截，下放到组件的值不能有null。因为null可能导致部分组件误动作，如Select会把null视为有效值，出现空选项。
@@ -111,14 +108,20 @@ const SyncValue = forwardRef((props: SyncValueProps) => {
     // 判断now_value 值与当前传入值是否相同，同则不触发onValueRelease
     const _value = finalvalue;
     if (Object.prototype.toString.call(getCompPropMapState) === '[object Function]') {
-      if (!equalsObj(getCompPropMapState!(compId, 'now_value'), _value) && onValueRelease) {
+      if (
+        !equalsObj(getCompPropMapState!(compId, 'now_value'), _value) &&
+        onValueRelease
+      ) {
         if (_value === '') {
           onValueRelease(undefined);
         } else {
           onValueRelease(_value);
         }
       }
-      if (!equalsObj(getCompPropMapState!(compId, 'now_selectedData'), _value) && onSelectedDataRelease) {
+      if (
+        !equalsObj(getCompPropMapState!(compId, 'now_selectedData'), _value) &&
+        onSelectedDataRelease
+      ) {
         if (_value === '' || _value === undefined) {
           onSelectedDataRelease([]);
         }
@@ -133,24 +136,24 @@ const SyncValue = forwardRef((props: SyncValueProps) => {
     if (!props.onChange) {
       return undefined;
     }
-    return (...e) => {
-      props.onChange!(...e);
-      if (props.children.props.onChange) {
-        props.children.props.onChange(...e);
-      }
-    };
+    return ((...e) => {
+        props.onChange!(...e);
+        if (props.children.props.onChange) {
+          props.children.props.onChange(...e);
+        }
+    });
   }, [props.onChange]);
 
   collectAction.onBlur = React.useMemo(() => {
     if (!props.onBlur) {
       return undefined;
     }
-    return (...e) => {
-      props.onBlur!(...e);
-      if (props.children.props.onBlur) {
-        props.children.props.onBlur(...e);
-      }
-    };
+    return ((...e) => {
+        props.onBlur!(...e);
+        if (props.children.props.onBlur) {
+          props.children.props.onBlur(...e);
+        }
+    });
   }, [props.onBlur]);
 
   if (!collectAction.onChange) {
@@ -169,8 +172,7 @@ const SyncValue = forwardRef((props: SyncValueProps) => {
     // 控件只读模式改造
     if (readOnly && !render) {
       return renderReadOnly(finalvalue || '--');
-    }
-    if (readOnly && typeof render === 'function') {
+    } if (readOnly && typeof render === 'function') {
       return render(finalvalue);
     }
   }

package/lib/pcpublic/src/components/pcfactory/src/utils/ahooks/index.ts

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

package/lib/pcpublic/src/components/pcfactory/src/utils/ahooks/useMap.ts

@@ -1,13 +1,16 @@
-import { useCallback, useMemo, useState } from 'react';
+import { useMemo, useState, useCallback } from 'react';
 
 function useMap<K, T>(initialValue?: Iterable<readonly [K, T]>) {
-  const initialMap = useMemo<Map<K, T>>(() => (initialValue === undefined ? new Map() : new Map(initialValue)) as Map<K, T>, []);
+  const initialMap = useMemo<Map<K, T>>(
+    () => (initialValue === undefined ? new Map() : new Map(initialValue)) as Map<K, T>,
+    [],
+  );
   const [map, setMap] = useState(initialMap);
 
   const stableActions = useMemo(
     () => ({
       set: (key: K, entry: T) => {
-        setMap(prev => {
+        setMap((prev) => {
           const temp = new Map(prev);
           temp.set(key, entry);
           return temp;
@@ -17,7 +20,7 @@ function useMap<K, T>(initialValue?: Iterable<readonly [K, T]>) {
         setMap(new Map(newMap));
       },
       remove: (key: K) => {
-        setMap(prev => {
+        setMap((prev) => {
           const temp = new Map(prev);
           temp.delete(key);
           return temp;
@@ -25,11 +28,11 @@ function useMap<K, T>(initialValue?: Iterable<readonly [K, T]>) {
       },
       reset: () => setMap(initialMap),
     }),
-    [setMap, initialMap]
+    [setMap, initialMap],
   );
 
   const utils = {
-    get: useCallback(key => map.get(key), [map]),
+    get: useCallback((key) => map.get(key), [map]),
     ...stableActions,
   };
 

package/lib/pcpublic/src/components/pcfactory/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/pcpublic/src/components/pcfactory/src/utils/ahooks/usePersistFn.ts

@@ -0,0 +1,17 @@
+import { useRef, useCallback } from 'react';
+
+const usePersistFn = (fn: any) => {
+  const ref = useRef(fn);
+  ref.current = fn;
+
+  const persistFn = useCallback((...args) => {
+    if (ref.current) {
+      return ref.current.apply(this, args);
+    }
+    return undefined;
+  }, []);
+
+  return persistFn;
+};
+
+export default usePersistFn;

package/lib/pcpublic/src/components/pcfactory/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/pcpublic/src/components/pcfactory/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;
     });