@conecli/cone-render 0.10.1-isv2.1 → 0.10.1-isv2.4

package/dist/components/base/CountDown/index.tsx

@@ -1 +1 @@
-import Taro from '@tarojs/taro'
    showDayToSecondState,
+import Taro from '@tarojs/taro';
  const {
    residueTime,
    serverTime,
    startTime,
    endTime,
    className,
    info,
    endTimeEndCallBack,
    startTimeEndCallBack,
    startTitleText,
    endTitleText,
    timeNumSpaceTextState,
    showDaytimeNumSpaceTextState,
    getDaysToHours,
    onlyShowDayState,
    showDayState,
    showHourState,
    showMinuteState,
    showSecondState,
    showDayToSecondState,
    fromStartText,
    fromEndText,
    numTextColor,
    textColor,
    numTextBgColor,
  } = props;
  const [endTimeFormat, setEndTimeFormat] = useState<{
    day: string | number;
    hour: string | number;
    minute: string | number;
    second: string | number;
  }>({
    day: 0,
    hour: 0,
    minute: 0,
    second: 0,
  });
  const countDownTimer = useRef<NodeJS.Timer | null>();
  const countDownTypeText = useRef<ComponentInterFace.CountDownTimerRef>({
    type: 'end',
    text: endTitleText,
    time: null,
  });
  
  const diffTimerRef = useRef({
    stopDocumentTime: 0,
    recoverDocumentTime: 0,
    diffTime: 0,
  });
  
  useEffect(() => {
    Taro.eventCenter.on(TaroEventType.PAGE_DOCUMENT_VISIBILITY_CHANGE, (state) => {
      if (state) {
        if (diffTimerRef.current.stopDocumentTime && diffTimerRef.current.stopDocumentTime > 0) {
          diffTimerRef.current.recoverDocumentTime = Date.now();
          diffTimerRef.current.diffTime =
            diffTimerRef.current.recoverDocumentTime - diffTimerRef.current.stopDocumentTime;
          changeTimerSetInterval(true);
        }
      } else {
        diffTimerRef.current.stopDocumentTime = Date.now();
        if (countDownTimer.current) {
          clearInterval(countDownTimer.current);
          countDownTimer.current = null;
        }
      }
    });
  }, []);
  useEffect(() => {
    if (serverTime > 0 || residueTime > 0) {
      let getNowEndTime = residueTime > 0 ? residueTime : endTime - serverTime;
      if (startTime && endTime) {
        if (serverTime <= startTime) {
          getNowEndTime = startTime - serverTime;
          countDownTypeText.current = {
            type: 'start',
            text: startTitleText,
            time: null,
          };
        } else {
          getNowEndTime = endTime - serverTime;
          countDownTypeText.current = {
            type: 'end',
            text: endTitleText,
            time: null,
          };
        }
      } else {
        countDownTypeText.current = {
          type: 'end',
          text: endTitleText,
          time: null,
        };
      }
      if (getNowEndTime > 0) {
        countDownTimeFormat(getNowEndTime);
        countDownTypeText.current.time = getNowEndTime;
        countDownTypeText.current.type === 'start' &&
          (countDownTypeText.current.endTime = endTime - serverTime);
        changeTimerSetInterval();
      } else {
        countDownTypeText.current = {
          type: 'end',
          text: endTitleText,
          time: 0,
        };
      }
    }
    return () => {
      countDownTimer.current && clearInterval(countDownTimer.current);
    };
  }, [serverTime]);
  
  const changeTimerSetInterval = (recoverState = false) => {
    countDownTimer.current && clearInterval(countDownTimer.current);
    recoverState && changeTimerFunc();
    countDownTimer.current = setInterval(changeTimerFunc, 1000);
  };
  const changeTimerFunc = () => {
    if (countDownTypeText.current.time && diffTimerRef.current.diffTime > 0) {
      countDownTypeText.current.time -= diffTimerRef.current.diffTime;
      countDownTypeText.current.type === 'start' &&
        countDownTypeText.current.endTime &&
        (countDownTypeText.current.endTime -= diffTimerRef.current.diffTime);
      console.log(
        '当前id倒计时获取倒计时息屏时间计算差值',
        countDownTimer.current,
        diffTimerRef.current,
        countDownTypeText.current,
      );
      diffTimerRef.current.stopDocumentTime = 0;
      diffTimerRef.current.recoverDocumentTime = 0;
      diffTimerRef.current.diffTime = 0;
    }
    if (countDownTypeText.current.time && countDownTypeText.current.time > 1000) {
      countDownTypeText.current.time -= 1000;
      countDownTypeText.current.type === 'start' &&
        countDownTypeText.current.endTime &&
        (countDownTypeText.current.endTime -= 1000);
      countDownTimeFormat(countDownTypeText.current.time);
    } else {
      countDownTypeText.current.time = 0;
      countDownTimeFormat(countDownTypeText.current.time);
      countDownTimer.current && clearInterval(countDownTimer.current);
      if (countDownTypeText.current.type === 'start') {
        let triggerStartTimeEndCallBackState = true;
        countDownTypeText.current = Object.assign({}, countDownTypeText.current, {
          type: 'end',
          text: endTitleText,
        });
        countDownTypeText.current.time = countDownTypeText.current.endTime;
        countDownTypeText.current.time && (countDownTypeText.current.time -= 1000);
        if (countDownTypeText.current.time && countDownTypeText.current.time > 0) {
          countDownTimer.current = setInterval(() => {
            if (countDownTypeText.current.time && diffTimerRef.current.diffTime > 0) {
              countDownTypeText.current.time -= diffTimerRef.current.diffTime;
              diffTimerRef.current.stopDocumentTime = 0;
              diffTimerRef.current.recoverDocumentTime = 0;
              diffTimerRef.current.diffTime = 0;
            }
            if (triggerStartTimeEndCallBackState && startTimeEndCallBack) {
              startTimeEndCallBack({
                type: 'start',
                endState: true,
                ...info,
              });
              triggerStartTimeEndCallBackState = false;
            }
            if (countDownTypeText.current.time && countDownTypeText.current.time > 1000) {
              countDownTypeText.current.time -= 1000;
              countDownTimeFormat(countDownTypeText.current.time);
            } else {
              endTimeEndCallBack &&
                endTimeEndCallBack({
                  type: 'end',
                  endState: true,
                  ...info,
                });
            }
          }, 1000);
        }
      } else {
        endTimeEndCallBack &&
          endTimeEndCallBack({
            type: 'end',
            endState: true,
            ...info,
          });
      }
    }
  };
  const countDownTimeFormat = (nowEndTime) => {
    let day = Math.floor(nowEndTime / 1000 / 86400);
    let hour = Math.floor((nowEndTime / 1000 / 3600) % 24);
    const minute = Math.floor((nowEndTime / 1000 / 60) % 60);
    const second = Math.floor((nowEndTime / 1000) % 60);
    if (getDaysToHours && day > 0) {
      hour = hour + day * 24;
      day = 0;
    }
    setEndTimeFormat({
      day,
      hour: `${hour}`.padStart(2, '0'),
      minute: `${minute}`.padStart(2, '0'),
      second: `${second}`.padStart(2, '0'),
    });
  };
  const numCustomStyle = numTextColor
    ? useRef({ color: numTextColor, backgroundColor: numTextBgColor })
    : useRef({});
  const textCustomStyle = textColor ? useRef({ color: textColor }) : useRef({});
  return (
    <View
      className={classNames(
        countDownStyle['d-count-down'],
        {
          [countDownStyle['d-ios-10-count-down']]: ios10State && !devToolPlatformState,
        },
        {
          [countDownStyle['d-en-count-down']]: isLanguageForEn,
        },
        className,
      )}
    >
      {countDownTypeText.current && countDownTypeText.current.text && (
        <Text className={classNames('d-count-down-title', 'font-jdzht')}>
          {countDownTypeText.current.text}
        </Text>
      )}
      <View className="display-inline-block">
        {fromStartText && <Text className="d-count-from-start">{fromStartText}</Text>}
        {onlyShowDayState && endTimeFormat.day > 0 ? (
          <>
            <Text
              className={classNames('d-count-down-time', 'd-day-time', 'font-jdzht')}
              style={numCustomStyle.current}
            >
              {endTimeFormat.day}
            </Text>
            <Text className="d-time-space-text d-day-space-text" style={textCustomStyle.current}>
              {showDaytimeNumSpaceTextState ? countDownTimeDay : ':'}
            </Text>
          </>
        ) : (
          <>
            {(showDayState || showDayToSecondState) && endTimeFormat.day > 0 && (
              <>
                <Text
                  className={classNames('d-count-down-time', 'd-day-time', 'font-jdzht')}
                  style={numCustomStyle.current}
                >
                  {endTimeFormat.day}
                </Text>
                <Text
                  className="d-time-space-text d-day-space-text"
                  style={textCustomStyle.current}
                >
                  {showDaytimeNumSpaceTextState ? countDownTimeDay : ':'}
                </Text>
              </>
            )}
            {showHourState && (
              <>
                <Text
                  className={classNames('d-count-down-time', 'd-hour-time', 'font-jdzht')}
                  style={numCustomStyle.current}
                >
                  {endTimeFormat.hour}
                </Text>
                <Text className="d-time-space-text" style={textCustomStyle.current}>
                  {(endTimeFormat.day > 0 && showDaytimeNumSpaceTextState) || timeNumSpaceTextState
                    ? countDownTimeHour
                    : ':'}
                </Text>
              </>
            )}
            {showMinuteState && (
              <>
                <Text
                  className={classNames('d-count-down-time', 'd-minute-time', 'font-jdzht')}
                  style={numCustomStyle.current}
                >
                  {endTimeFormat.minute}
                </Text>
                <Text className="d-time-space-text" style={textCustomStyle.current}>
                  {(endTimeFormat.day > 0 && showDaytimeNumSpaceTextState) || timeNumSpaceTextState
                    ? countDownTimeMin
                    : endTimeFormat.day > 0
                      ? ''
                      : ':'}
                </Text>
              </>
            )}
            {showSecondState && (endTimeFormat.day <= 0 || showDayToSecondState) && (
              <>
                <Text
                  className={classNames('d-count-down-time', 'd-second-time', 'font-jdzht')}
                  style={numCustomStyle.current}
                >
                  {endTimeFormat.second}
                </Text>
                {(timeNumSpaceTextState ||
                  (showDayToSecondState && showDaytimeNumSpaceTextState)) && (
                  <Text className="d-time-space-text" style={textCustomStyle.current}>
                    秒
                  </Text>
                )}
              </>
            )}
          </>
        )}
        {fromEndText && <Text className="d-count-from-end">{fromEndText}</Text>}
      </View>
    </View>
  );
  return useMemo(() => {
    return <CountDownTimer {...props} />;
  }, []);
  residueTime: -1, 
  serverTime: null,
  className: null,
  startTime: null,
  endTime: null,
  info: null, 
  startTitleText: '距活动开始',
  endTitleText: '距活动结束',
  fromEndText: null,
  startTimeEndCallBack: null,
  endTimeEndCallBack: null,
  timeNumSpaceTextState: false, 
  showDaytimeNumSpaceTextState: true, 
  onlyShowDayState: false, 
  showDayState: false, 
  showDayToSecondState: false, 
  getDaysToHours: false, 
  showHourState: true,
  showMinuteState: true,
  showSecondState: true,
  numTextColor: null,
  textColor: null,
  numTextBgColor: null,

package/dist/components/base/CustomScrollView/index-back.tsx

@@ -0,0 +1 @@
+import React, { useRef, useEffect } from 'react';
  isH5AndJdShopView,
  isAndroidDevice,
  isJdAndAndroidDevice,
  isJdAndIosDevice,
  isIosDevice,
  isJdApp,
  isWxMin,
  isH5AndJdShopViewH5Scroll,
  isH5AndJdShopH5CustomScrollView,
  isH5,
  isAppClassifyPage,
  lodashThrottle,
  START: 'start',
  MOVE: 'move',
  END: 'end',
  const {
    style = {},
    scrollX = false,
    scrollY = false,
    scrollWithAnimation = true,
    iosNeedDisableVertical = false, 
    className = null,
    dispatchTouchMove = true, 
    children,
    ...otherProps
  } = props;
  const rootEleNode = isH5 && document?.querySelector('body');
  const needShowHighVersion =
    isH5AndJdShopViewH5Scroll && global.info.queryInfo?.downgraded !== 'true';
  const mLastClientPosRef = useRef({
    mLastClientX: 0,
    mLastClientY: 0,
  });
  const isJdAndH5ScrollState = needShowHighVersion || isH5AndJdShopH5CustomScrollView;
  
  const touchstartEventBubbleFunc = (e) => {
    const isH5SwiperCustomEle = e?.target?.closest('.J_h5SwiperCustom');
    if (!isH5SwiperCustomEle) {
      const hasCustomEle = e
        ? e?.target?.closest('.J_customScroll') || e?.target?.closest('.J_customLayout')
        : false;
      if (isJdAndAndroidDevice && !hasCustomEle) {
        window.JdAndroid && window.JdAndroid.requestEvent(false);
      }
      !hasCustomEle &&
        rootEleNode &&
        rootEleNode.classList.contains('over-hidden') &&
        rootEleNode.classList.remove('over-hidden');
    }
  };
  const touchstartEventCaptureFunc = (e) => {
    if (e && !e?.target?.closest('.J_h5SwiperCustom') && !e?.target?.closest('.J_customLayout')) {
      rootEleNode &&
        rootEleNode.classList.contains('over-hidden') &&
        rootEleNode.classList.remove('over-hidden');
    }
  };
  useEffect(() => {
    isJdApp &&
      !window.JDJshopViewInfo.getAndroidTouchSlopState &&
      nativePageGetScaledTouchSlop((res) => {
        console.log('获取安卓系统滑动阈值', res);
        window.JDJshopViewInfo.androidTouchSlop = res;
        window.JDJshopViewInfo.getAndroidTouchSlopState = true;
      });
    if (isJdAndH5ScrollState && rootEleNode && !rootEleAddEventListenerState) {
      global?.removeJdAndroidRquestEventForTouchStart &&
        global.removeJdAndroidRquestEventForTouchStart();
      rootEleNode.addEventListener('touchstart', touchstartEventBubbleFunc, false);
      
      rootEleNode.addEventListener('touchstart', touchstartEventCaptureFunc, true);
      rootEleAddEventListenerState = true;
      console.log('customScrollView 初始化document监听完成');
    }
    return () => {
      if (isJdAndH5ScrollState && rootEleNode && rootEleAddEventListenerState) {
        console.log('customScrollView document监听取消完成');
        rootEleNode.removeEventListener('touchstart', touchstartEventBubbleFunc, false);
        rootEleNode.removeEventListener('touchstart', touchstartEventCaptureFunc, true);
      }
    };
  }, []);
  
  const androidDeviceStopNativeScrollEvent = (touchType) => {
    isJdApp &&
      isAndroidDevice &&
      window?.JdAndroid &&
      window?.JdAndroid.requestEvent(touchType === TouchType.START);
  };
  const iosDeviceStopNativeScrollEvent = (e, touchType, sendIosState = true) => {
    sendIosState && iosDeviceSendRouter(touchType);
  };
  
  const iosDeviceSendRouter = (state: string) => {
    window?.webkit?.messageHandlers?.MobileNavi?.postMessage?.({
      method: 'callRouterModuleWithParams',
      params: {
        routerURL: 'router://JDShopModule/processShoph5SlideState',
        routerParam: {
          slideDirection: 'horizontal',
          needDisableVertical: `${iosNeedDisableVertical}`,
          state,
        },
        callBackId: new Date().getTime(),
      },
    });
  };
  const stopNativeScrollEvent = (e: Event, touchType, sendIosState = true) => {
    if (isJdApp) {
      if (isIosDevice && !isAppClassifyPage) {
        iosDeviceStopNativeScrollEvent(e, touchType, sendIosState);
      } else if (isAndroidDevice) {
        androidDeviceStopNativeScrollEvent(touchType);
      }
    }
  };
  
  const GetSlideAngle = (dx, dy) => {
    return (Math.atan2(dy, dx) * 180) / Math.PI;
  };
  
  const GetSlideDirection = (startX, startY, endX, endY) => {
    const dy = startY - endY;
    const dx = endX - startX;
    let result = 0;
    if (Math.abs(dx) < 2 && Math.abs(dy) < 2) {
      return result;
    }
    const angle = GetSlideAngle(dx, dy);
    if (angle >= -45 && angle < 45) {
      result = 4;
    } else if (angle >= 45 && angle < 135) {
      result = 1;
    } else if (angle >= -135 && angle < -45) {
      result = 2;
    } else if ((angle >= 135 && angle <= 180) || (angle >= -180 && angle < -135)) {
      result = 3;
    }
    return result;
  };
  const changeTouchStart = (e) => {
    if (isJdApp) {
      stopNativeScrollEvent(e, TouchType.START, !iosNeedDisableVertical);
      if (isH5AndJdShopView || isH5AndJdShopH5CustomScrollView) {
        isJdAndH5ScrollState && rootEleNode && rootEleNode.classList.add('over-hidden');
        const touchEvent = e?.originalEvent?.targetTouches[0] || e?.targetTouches[0];
        mLastClientPosRef.current.mLastClientX = touchEvent.clientX;
        mLastClientPosRef.current.mLastClientY = touchEvent.clientY;
      }
    }
  };
  const changeTouchEnd = (e) => {
    stopNativeScrollEvent(e, TouchType.END);
    mLastClientPosRef.current.mLastClientX = 0;
    mLastClientPosRef.current.mLastClientY = 0;
  };
  const triggerIosTouchMove = () => {
    isJdAndIosDevice && iosDeviceStopNativeScrollEvent(null, TouchType.START, true);
  };
  
  const lodashThrottleTriggerIosTouchMove = lodashThrottle(triggerIosTouchMove, 500);
  
  const recoverRootEleVerticalScroll = (touchEvent) => {
    const direction = GetSlideDirection(
      mLastClientPosRef.current.mLastClientX,
      mLastClientPosRef.current.mLastClientY,
      touchEvent.clientX,
      touchEvent.clientY,
    );
    if (direction === 1 || direction === 2) {
      rootEleNode &&
        rootEleNode.classList.contains('over-hidden') &&
        rootEleNode.classList.remove('over-hidden');
    }
  };
  const changeTouchMove = (e) => {
    if (isH5AndJdShopView || isH5AndJdShopH5CustomScrollView) {
      const touchEvent = e?.originalEvent?.targetTouches[0] || e?.targetTouches[0];
      const xDiff = Math.abs(touchEvent.clientX - mLastClientPosRef.current.mLastClientX).toFixed(
        2,
      );
      const yDiff = Math.abs(touchEvent.clientY - mLastClientPosRef.current.mLastClientY).toFixed(
        2,
      );
      if (isJdApp) {
        if (xDiff >= window.JDJshopViewInfo.androidTouchSlop) {
          iosNeedDisableVertical && isJdApp && lodashThrottleTriggerIosTouchMove();
        } else if (yDiff > window.JDJshopViewInfo.androidTouchSlop) {
          stopNativeScrollEvent(e, TouchType.END);
        }
      }
      isJdAndH5ScrollState && recoverRootEleVerticalScroll(touchEvent);
    }
    if (!dispatchTouchMove) {
      return;
    }
    const parentNode = e.target?.parentNode;
    if (!parentNode) {
      return;
    }
    const event = new TouchEvent('touchmove', e);
    parentNode.dispatchEvent(event);
  };
  if (scrollX && isJdApp && !isIgnorePreventNative) {
    return (
      <ScrollView
        scrollX
        onTouchStart={changeTouchStart}
        onTouchEnd={changeTouchEnd}
        onTouchCancel={changeTouchEnd}
        onTouchMove={changeTouchMove}
        enhanced
        showScrollbar={false}
        style={style}
        className={classNames(
          className,
          {
            [customScrollViewStyle['d-custom-ios-h5-extend-border-radius']]: isIosDevice,
          },
          'J_customScroll',
        )}
        scrollY
        scrollWithAnimation
        {...otherProps}
      >
        {children}
      </ScrollView>
    );
  } else {
    return (
      <ScrollView
        scrollX
        scrollY
        scrollWithAnimation
        enhanced
        showScrollbar={false}
        {...otherProps}
        className={classNames(
          className,
          {
            [customScrollViewStyle['d-custom-ios-mini-extend-border-radius']]:
              isIosDevice && isWxMin && scrollX && style['borderRadius'],
          },
          {
            [customScrollViewStyle['d-custom-ios-h5-extend-border-radius']]: isIosDevice,
          },
          {
            [customScrollViewStyle['d-custom-mini-hide-scroll']]: isWxMin,
          },
        )}
        style={style}
      >
        {children}
      </ScrollView>
    );
  }