How to use the axios.isCancel function in axios

}).catch((error) => {
            if (axios.isCancel(error)) {
                console.log(error.message);
            } else {
                mock.restore(); //// JUST FOR MOCKING
                dispatch({ type: types.FETCH_GROUPS_ERROR, error: error.response.data });
            }
        });
    };

}, error => {
  let message = '';
  if(axios.isCancel(error)) {
    source.cancel('取消网络请求')
  }  
  // 抛出错误
  if(error && error.response){  
    let { response } = error,
        { status, data, config: responseConfig } = response,
        { method: methodType } = responseConfig;
    switch(status){
      //错误的请求
      case '400':
        message = `400:${ methodType }:服务器不理解请求的语法`;
      break;
      case '403':
        message = `403:${ methodType }:服务器拒绝请求`;
      break;
      //页面丢失

var convertResponse = curry(function (startedAt, axiosResult) {
        var end = toNumber(new Date());
        var duration = end - startedAt;
        // new in Axios 0.13 -- some data could be buried 1 level now
        var isError = axiosResult instanceof Error || axios.isCancel(axiosResult);
        var axiosResponse = axiosResult;
        var axiosError = axiosResult;
        var response = isError ? axiosError.response : axiosResponse;
        var status = (response && response.status) || null;
        var problem = isError
            ? getProblemFromError(axiosResult)
            : getProblemFromStatus(status);
        var originalError = isError
            ? axiosError
            : null;
        var ok = in200s(status);
        var config = axiosResult.config || null;
        var headers = (response && response.headers) || null;
        var data = (response && response.data) || null;
        // give an opportunity for anything to the response transforms to change stuff along the way
        var transformedResponse = {

}).catch(function (e) {
                    Notify.unblockUI();

                    if (Axios.isCancel(e)) {
                        // run in background
                        return
                    }

                    Notify.error(this.$gettext("Indexing failed"));

                    ctx.busy = false;
                    ctx.completed = 0;
                    ctx.fileName = '';
                });
            },

.catch(error => {
          if (axios.isCancel(error)) return;
          this.tracerApiSource = null;
          this.setState({ building: false });
          this.handleError(error);
        });
    } else {

(error: AxiosError) => {
      onApiCallFinish(error.config.apiCallId);

      if (!axios.isCancel(error)) {
        onError(error);
        throw error;
      }
    }
  );

private handleRequestError = (error: AxiosError) => {
    const {path: url} = this.options

    if (axios.isCancel(error)) {
      throw new CancelError()
    }

    if (error.response) {
      throw new RequestError({
        headers: error.config.headers,
        url: error.config.url || url,
      }, {
        status: error.response.status,
        statusText: error.response.statusText,
      })
    }

    throw error
  }

const filter: API.GlobalLogFilter = {
			author: this.state.author,
			branch: this.state.branch,
			from: this.state.from,
			till: this.state.till,
			all: this.state.all,
		};
		try {
			this.setState({ loading: true });
			this.cts = axios.CancelToken.source();
			const data = await API.getGlobalLog(filter, { cancelToken: this.cts.token });
			this.setState({ data, loading: false });
			onLoaded();
		} catch (error) {
			this.setState({ loading: false });
			if (axios.isCancel(error)) {
				onLoaded();
			} else {
				onError(error);
			}
		}
	}

}).then((val) => {
      if(axios.isCancel(val)) return false;
      this.props.onLoadingStateChange(false);
    });
    return requestPromise;

.catch((err: Error) => {
        if (axios.isCancel(err)) {
          throw new RequestCanceledError(err.message)
        } else {
          throw err
        }
      })
      .then((resp: AxiosResponse) => {