@lingxiteam/ebe-utils 0.5.5 → 0.5.7

package/lib/public/src/components/pcfactory/src/utils/Empty/empty.tsx

@@ -0,0 +1,37 @@
+export default (props: any) => {
+  return (
+    <svg
+      width="72"
+      height="49"
+      viewBox="0 0 72 49"
+      fill="none"
+      xmlns="http://www.w3.org/2000/svg"
+      {...props}
+    >
+      <path
+        d="M36 44.3743C53.6731 44.3743 68 41.2636 68 37.4263C68 33.589 53.6731 30.4783 36 30.4783C18.3269 30.4783 4 33.589 4 37.4263C4 41.2636 18.3269 44.3743 36 44.3743Z"
+        fill="#F5F5F5"
+      />
+      <path
+        d="M59 17.532L48.854 6.11536C48.367 5.33718 47.656 4.8667 46.907 4.8667H25.093C24.344 4.8667 23.633 5.33718 23.146 6.11437L13 17.533V26.7034H59V17.532Z"
+        fill="white"
+      />
+      <path
+        fillRule="evenodd"
+        clipRule="evenodd"
+        d="M22.7454 5.81243C23.2951 4.95583 24.1365 4.3667 25.093 4.3667H46.907C47.8636 4.3667 48.7049 4.95589 49.2547 5.81352L59.5 17.3419V27.2034H12.5V17.3429L22.7454 5.81243ZM25.093 5.3667C24.565 5.3667 23.9946 5.70178 23.5697 6.37986L23.5475 6.41526L13.5 17.723V26.2034H58.5V17.7221L48.4524 6.41616L48.4302 6.38061C48.0053 5.70167 47.4349 5.3667 46.907 5.3667H25.093Z"
+        fill="#E5E5E5"
+      />
+      <path
+        d="M45.613 20.6795C45.613 19.0864 46.607 17.7713 47.84 17.7703H59V35.7726C59 37.8799 57.68 39.6069 56.05 39.6069H15.95C14.32 39.6069 13 37.8789 13 35.7726V17.7703H24.16C25.393 17.7703 26.387 19.0834 26.387 20.6765V20.6984C26.387 22.2914 27.392 23.5778 28.624 23.5778H43.376C44.608 23.5778 45.613 22.2795 45.613 20.6865V20.6795V20.6795Z"
+        fill="#FAFAFA"
+      />
+      <path
+        fillRule="evenodd"
+        clipRule="evenodd"
+        d="M47.84 17.2703L59.5 17.2703V35.7726C59.5 36.9273 59.1389 37.9951 58.5328 38.7845C57.9264 39.5743 57.0532 40.1069 56.05 40.1069H15.95C14.9467 40.1069 14.0735 39.574 13.4671 38.7841C12.8611 37.9946 12.5 36.9269 12.5 35.7726V17.2703H24.16C24.966 17.2703 25.6585 17.7006 26.1333 18.3226C26.6078 18.9442 26.887 19.7795 26.887 20.6765V20.6984C26.887 22.1392 27.7776 23.0778 28.624 23.0778H43.376C44.2202 23.0778 45.113 22.1302 45.113 20.6865V20.6795C45.113 19.7825 45.3922 18.9468 45.8665 18.3247C46.3411 17.7023 47.0339 17.2709 47.84 17.2703ZM13.5 18.2703V35.7726C13.5 36.7246 13.7989 37.5741 14.2604 38.1752C14.7215 38.7759 15.3233 39.1069 15.95 39.1069H56.05C56.6768 39.1069 57.2786 38.776 57.7397 38.1755C58.2011 37.5746 58.5 36.7252 58.5 35.7726V18.2703H47.8402C47.4134 18.2707 46.9923 18.4974 46.6617 18.931C46.3308 19.365 46.113 19.9835 46.113 20.6795V20.6865C46.113 22.4288 44.9958 24.0778 43.376 24.0778H28.624C27.0064 24.0778 25.887 22.4437 25.887 20.6984V20.6765C25.887 19.9805 25.6692 19.3627 25.3384 18.9294C25.008 18.4965 24.587 18.2703 24.16 18.2703H13.5Z"
+        fill="#E5E5E5"
+      />
+    </svg>
+  );
+};

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

@@ -0,0 +1,29 @@
+// @ts-ignore
+import Loadable from 'react-loadable';
+
+/**
+ * 通用的加载中组件
+ * @param {Object} props
+ */
+export const LoadingComponennt = (props: any) => {
+  // console.log("加载中组件", props);
+  return <></>;
+};
+
+const loaderHelper = (loaderRet: any, loading = LoadingComponennt) => {
+  // console.log("loaderHelper", arguments);
+  if (loaderRet === undefined) {
+    throw TypeError('请传入参数，格式： import("xxx")');
+  }
+  return Loadable({
+    loader: () => loaderRet,
+    loading,
+  });
+};
+
+export const ContainerView = (Com: any) => (props: any) => {
+  const { forwardedRef, ...restProps } = props;
+  return <Com {...restProps} ref={forwardedRef} />;
+};
+
+export default loaderHelper;

package/lib/public/src/components/pcfactory/src/utils/PropsType.ts

@@ -0,0 +1,21 @@
+export type WufengAction = 'PAGE_CONTAINER_BOX';
+
+export type ValueOf<T> = T[keyof T];
+
+const ACTION_PREFIX = 'LCDP_CENTER_';
+
+export const LCDP_ACTIONS = {
+  apis: `${ACTION_PREFIX}APIS`, // api
+  utils: `${ACTION_PREFIX}UTILS`, // 一些工具类
+} as const;
+
+export type ActionType = ValueOf<typeof LCDP_ACTIONS>;
+
+/**
+ * 自定义函数入参
+ */
+export interface ExpressionRenderingParams {
+  value?: string;
+  code?: string;
+  originCode?: string;
+}

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

@@ -0,0 +1,218 @@
+import React, { forwardRef, useEffect, useMemo } from 'react';
+import { useDummyFormContext } from './DummyFormContext';
+import renderReadOnly from './renderReadOnly';
+
+export interface SyncValueProps {
+  onValueRelease?: (value: any) => void;
+  value?: any;
+  compId?: string;
+  getCompPropMapState?: (value: any, str: string) => any;
+  onSelectedDataRelease?: (value: []) => any;
+  className?: string;
+  onChange?: React.FormEventHandler;
+  onBlur?: React.FocusEventHandler;
+  children: React.ReactElement;
+  readOnly?: boolean;
+  render?: (data: any) => any;
+  isMask?: any;
+  dataMaskUtil?: any;
+  // dataMaskInit?: Function;
+  ignoreReadOnlyFlag?: boolean;
+}
+
+// 该方法移出SyncValue，避免实际运行时创建过多闭包
+const equalsObj = (oldData: any, newData: any) => {
+  // 如果其中一边的运算数是undefined，那么不要去跑原型处理等后续方法，可能提高些许性能
+  if (oldData === undefined || newData === undefined)
+    return oldData === newData;
+  // 类型为基本类型时,如果相同,则返回true
+  if (oldData === newData) return true;
+  if (
+    Object.prototype.toString.call(oldData) === '[object Object]' &&
+    Object.prototype.toString.call(newData) === '[object Object]' &&
+    Object.entries(oldData).toString() === Object.entries(newData).toString()
+  ) {
+    return false;
+  }
+  if (
+    Object.prototype.toString.call(oldData) === '[object Array]' &&
+    Object.prototype.toString.call(newData) === '[object Array]' &&
+    oldData.length === newData.length
+  ) {
+    // 类型为数组并且数组长度相同
+    for (let i = 0, { length } = oldData; i < length; i += 1) {
+      if (!equalsObj(oldData[i], newData[i])) {
+        // 如果数组元素中具有不相同元素,返回false
+        return false;
+      }
+    }
+  } else {
+    // 其它类型,均返回false
+    return false;
+  }
+  return true;
+};
+
+const SyncValue = forwardRef((props: SyncValueProps) => {
+  const {
+    onValueRelease,
+    value = undefined,
+    compId,
+    getCompPropMapState,
+    onSelectedDataRelease,
+    className,
+    readOnly,
+    render,
+    isMask,
+    dataMaskUtil,
+  } = props;
+
+  const form = useDummyFormContext();
+  const fieldName = useMemo(() => {
+    if (!form?.fieldCompIdMap) return '';
+    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;
+  }, [compId]);
+
+  useEffect(() => {
+    if (form?.enableValidateField && fieldName) {
+      form?.enableValidateField(fieldName);
+    }
+    return () => {
+      // 组件被隐藏时WithSyncValue会被卸载，移除他的校验定义
+      if (form?.removeValidateField && fieldName) {
+        form?.removeValidateField(fieldName);
+      }
+    };
+  }, []);
+  let finalvalue = form?.nowFormData ? form?.nowFormData[fieldName] : value;
+  if (
+    form?.nowFormData &&
+    form.nowFormData[fieldName] === undefined &&
+    fieldName &&
+    defaultValue &&
+    !form.defaultInited[fieldName]
+  ) {
+    // 在这里触发默认值行为，原则上这个操作只应该发生一次
+    form.defaultInited[fieldName] = true;
+    form.setFieldsValue({
+      [fieldName]: defaultValue,
+    });
+  }
+  const finalMask = form?.dataMaskInst?.[fieldName] ?? isMask?.current;
+  if (finalMask && dataMaskUtil) {
+    // 脱敏值
+    finalvalue = dataMaskUtil.processDataMaskValue(finalvalue, finalMask);
+  }
+  // 把null值在此处拦截，下放到组件的值不能有null。因为null可能导致部分组件误动作，如Select会把null视为有效值，出现空选项。
+  if (finalvalue === null) {
+    finalvalue = undefined;
+  }
+  useEffect(() => {
+    // useEffect 无法正确判断数组与对象是否有变化，故造成死循环
+    // 判断now_value 值与当前传入值是否相同，同则不触发onValueRelease
+    const _value = finalvalue;
+    if (
+      Object.prototype.toString.call(getCompPropMapState) ===
+      '[object Function]'
+    ) {
+      if (
+        !equalsObj(getCompPropMapState!(compId, 'now_value'), _value) &&
+        onValueRelease
+      ) {
+        if (_value === '') {
+          onValueRelease(undefined);
+        } else {
+          onValueRelease(_value);
+        }
+      }
+      if (
+        !equalsObj(getCompPropMapState!(compId, 'now_selectedData'), _value) &&
+        onSelectedDataRelease
+      ) {
+        if (_value === '' || _value === undefined) {
+          onSelectedDataRelease([]);
+        }
+      }
+    }
+  }, [finalvalue]);
+  const collectAction: React.AllHTMLAttributes<Element> = {
+    value: finalvalue,
+  };
+
+  collectAction.onChange = React.useMemo(() => {
+    if (!props.onChange) {
+      return undefined;
+    }
+    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);
+      }
+    };
+  }, [props.onBlur]);
+
+  if (!collectAction.onChange) {
+    delete collectAction.onChange;
+  }
+
+  if (!collectAction.onBlur) {
+    delete collectAction.onBlur;
+  }
+
+  if (className) {
+    collectAction.className = `${className} ${
+      props?.children?.props.className || ''
+    }`;
+  }
+
+  if (!props.ignoreReadOnlyFlag) {
+    // 控件只读模式改造
+    if (readOnly && !render) {
+      return renderReadOnly(finalvalue || '--');
+    }
+    if (readOnly && typeof render === 'function') {
+      return render(finalvalue);
+    }
+  }
+
+  // 兼容Rate控件值修改
+  if (
+    props.compId?.includes('Rate') &&
+    Array.isArray(props.children.props.children)
+  ) {
+    let propsChange: any = null;
+    for (let i = 0; i < props.children.props.children.length; i += 1) {
+      const item = props.children.props.children[i];
+      if (item.props?.onChange) {
+        propsChange = item;
+        break;
+      }
+    }
+    return propsChange ? React.cloneElement(propsChange, collectAction) : null;
+  }
+  return props.children
+    ? React.cloneElement(props.children, collectAction)
+    : null;
+});
+
+export default SyncValue;

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

@@ -0,0 +1,22 @@
+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 useSetState, { SetState } from './useSetState';
+import useUpdate from './useUpdate';
+import useUpdateEffect from './useUpdateEffect';
+
+export type { SetState };
+export {
+  usePrevious,
+  useSafeState,
+  useMemoizedFn,
+  useUpdateEffect,
+  useDeepCompareEffect,
+  useSetState,
+  useMap,
+  useUpdate,
+  useCreation,
+};

package/lib/public/src/components/pcfactory/src/utils/ahooks/useCreation.ts

@@ -0,0 +1,23 @@
+import { useRef } from 'react';
+
+export default function useCreation<T>(factory: () => T, deps: any[]) {
+  const { current } = useRef({
+    deps,
+    obj: undefined as undefined | T,
+    initialized: false,
+  });
+  if (current.initialized === false || !depsAreSame(current.deps, deps)) {
+    current.deps = deps;
+    current.obj = factory();
+    current.initialized = true;
+  }
+  return current.obj as T;
+}
+
+function depsAreSame(oldDeps: any[], deps: any[]): boolean {
+  if (oldDeps === deps) return true;
+  for (let i = 0; i < oldDeps.length; i += 1) {
+    if (oldDeps[i] !== deps[i]) return false;
+  }
+  return true;
+}

package/lib/public/src/components/pcfactory/src/utils/ahooks/useDeepCompareEffect.ts

@@ -0,0 +1,27 @@
+import { isEqual } from 'lodash';
+import { DependencyList, EffectCallback, useEffect, useRef } from 'react';
+
+const depsEqual = function depsEqual(
+  aDeps: DependencyList,
+  bDeps?: DependencyList,
+) {
+  let bDepsList = bDeps;
+  if (bDepsList === undefined) {
+    bDepsList = [];
+  }
+
+  return isEqual(aDeps, bDepsList);
+};
+
+export const useDeepCompareEffect = (
+  effect: EffectCallback,
+  deps: DependencyList,
+) => {
+  const ref = useRef<DependencyList>();
+  const signalRef = useRef(0);
+  if (!depsEqual(deps, ref.current)) {
+    ref.current = deps;
+    signalRef.current += 1;
+  }
+  useEffect(effect, [signalRef.current]);
+};

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

@@ -0,0 +1,46 @@
+import { useCallback, useMemo, useState } 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 [map, setMap] = useState(initialMap);
+
+  const stableActions = useMemo(
+    () => ({
+      set: (key: K, entry: T) => {
+        setMap((prev) => {
+          const temp = new Map(prev);
+          temp.set(key, entry);
+          return temp;
+        });
+      },
+      setAll: (newMap: Iterable<readonly [K, T]>) => {
+        setMap(new Map(newMap));
+      },
+      remove: (key: K) => {
+        setMap((prev) => {
+          const temp = new Map(prev);
+          temp.delete(key);
+          return temp;
+        });
+      },
+      reset: () => setMap(initialMap),
+    }),
+    [setMap, initialMap],
+  );
+
+  const utils = {
+    get: useCallback((key) => map.get(key), [map]),
+    ...stableActions,
+  };
+
+  return [map, utils] as const;
+}
+
+export default useMap;

package/lib/public/src/components/pcfactory/src/utils/ahooks/useMemoizedFn.ts

@@ -0,0 +1,27 @@
+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>;
+
+function useMemoizedFn<T extends noop>(fn: T) {
+  const fnRef = useRef<T>(fn);
+
+  // why not write `fnRef.current = fn`?
+  // https://github.com/alibaba/hooks/issues/728
+  fnRef.current = useMemo(() => fn, [fn]);
+
+  const memoizedFn = useRef<PickFunction<T>>();
+  if (!memoizedFn.current) {
+    memoizedFn.current = function (this, ...args) {
+      return fnRef.current.apply(this, args);
+    };
+  }
+
+  return memoizedFn.current as T;
+}
+
+export default useMemoizedFn;

package/lib/public/src/components/pcfactory/src/utils/ahooks/usePrevious.ts

@@ -0,0 +1,19 @@
+import { useRef } from 'react';
+
+export type compareFunction<T> = (prev: T | undefined, next: T) => boolean;
+
+function usePrevious<T>(state: T, compare?: compareFunction<T>): T | undefined {
+  const prevRef = useRef<T>();
+  const curRef = useRef<T>();
+
+  const needUpdate =
+    typeof compare === 'function' ? compare(curRef.current, state) : true;
+  if (needUpdate) {
+    prevRef.current = curRef.current;
+    curRef.current = state;
+  }
+
+  return prevRef.current;
+}
+
+export default usePrevious;

package/lib/public/src/components/pcfactory/src/utils/ahooks/useSafeState.ts

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

package/lib/public/src/components/pcfactory/src/utils/ahooks/useSetState.ts

@@ -0,0 +1,26 @@
+import isFunction from 'lodash/isFunction';
+import { useCallback, useState } from 'react';
+
+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),
+) => void;
+
+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 newState = isFunction(patch) ? patch(prevState) : patch;
+      return newState ? { ...prevState, ...newState } : prevState;
+    });
+  }, []);
+
+  return [state, setMergeState];
+};
+
+export default useSetState;

package/lib/public/src/components/pcfactory/src/utils/ahooks/useUnmountedRef.ts

@@ -0,0 +1,14 @@
+import { useEffect, useRef } from 'react';
+
+const useUnmountedRef = () => {
+  const unmountedRef = useRef(false);
+  useEffect(() => {
+    unmountedRef.current = false;
+    return () => {
+      unmountedRef.current = true;
+    };
+  }, []);
+  return unmountedRef;
+};
+
+export default useUnmountedRef;

package/lib/public/src/components/pcfactory/src/utils/ahooks/useUpdate.ts

@@ -0,0 +1,9 @@
+import { useCallback, useState } from 'react';
+
+const useUpdate = () => {
+  const [, setState] = useState({});
+
+  return useCallback(() => setState({}), []);
+};
+
+export default useUpdate;

package/lib/public/src/components/pcfactory/src/utils/ahooks/useUpdateEffect.ts

@@ -0,0 +1,16 @@
+import { useEffect, useRef } from 'react';
+
+const useUpdateEffect: typeof useEffect = (effect, deps) => {
+  const isMounted = useRef(false);
+
+  useEffect(() => {
+    if (!isMounted.current) {
+      isMounted.current = true;
+    } else {
+      return effect();
+    }
+    return () => {};
+  }, deps);
+};
+
+export default useUpdateEffect;

package/lib/public/src/components/pcfactory/src/utils/basicStatusTransfer.ts

@@ -0,0 +1,32 @@
+// 把数字状态转换成对应的实际props
+const basicStatusTransfer = (basicStatusValue: number | string) => {
+  switch (+basicStatusValue) {
+    case 2: // 隐藏
+      return {
+        disabled: false,
+        visible: false,
+        readOnly: false,
+      };
+    case 3: // 禁用
+      return {
+        disabled: true,
+        visible: true,
+        readOnly: false,
+      };
+    case 4: // 只读
+      return {
+        disabled: false,
+        visible: true,
+        readOnly: true,
+      };
+    case 1: // 默认情况
+    default:
+      return {
+        disabled: false,
+        visible: true,
+        readOnly: false,
+      };
+  }
+};
+
+export default basicStatusTransfer;