//===========新功能===========
// 注意类型 HttpClient 和 实例 httpClient 
import { HttpClient} from "uni-httpclient"; // 名字具体看你把该库放在哪
 
// setupDefaults 是 HttpClient 这个类的静态函数
// 你必须配置以下内容才能将所有的拦截器都打开，如果不配置 其中某个比如 retryCount, 则重试拦截器将不会添加
HttpClient.setupDefaults({
    timeout:15,
    retryCount:1, // 建议重试1次就好
    retryDelay:1000, //1秒，默认值
    statusCodeError:true,
    baseUrl:"http://localhost:500/api/"
})
 
//=======自定义方式=============
 
//1. 配置 在 main.ts 中配置
import { HttpClient} from "uni-httpclient"; // 名字具体看你把该库放在哪
const domainIntercepter = new AutoDomainIntercepter((url)=>{
    //url 为请求url, 可以根据url添加自己逻辑， 
    //比如 /api 映射到 api.com,  /v2 映射到 v2.api.com
 
    return "http://localhost:8080"
})
const jwtTokenIntercepter = new JwtTokenIntercepter((url)=>{
    // 因为拦截器会按顺序执行，所以此处的url已经是完整的url,
    // 在这里可以 url 参数 给不同的域名/路径追加不同的token
    let domain = "*"
    if (url.startWith("http://a.example.com"){
        domain = "a"
    }
    else if ( url.startWith("http://b.example.com")){
        domain = "b";
    }
    // tokenStorage 是一个自己实现的类，用来管理token
    return tokenStorage.getToken(domain);
})
httpClient.intercepters.push(new TimeoutIntercepter( 20 )); // 添加 使用 timeout 参数的必备拦截器， 可以不填，填上则未全局超时， 
//记得在 下载和上传 api上 利用 preventTimeout:true 来阻止该拦截器发生作用，（上传和下载是相对比较耗时的操作）
HttpClient.intercepters.push(domainIntercepter)
HttpClient.intercepters.push(jwtTokenIntercepter)
 

import { httpClient } from "uni-httpclient";
// 如果不喜欢 httpClient 这个词, 可以用 as 重命名
// import { httpClient as http} from "uni-httpclient";
httpClient.get<any>(`/api/user/info`)
.then(r=>{
    // 处理返回的数据
})

import {CancelToken } from "我们的库地址";
let cancelToken = new CancelToken();
httpClient.Post("/api/do",null,null,null,{ cancelToken: cancelToken })
.then(x=> {      });
 
// 需要取消的时候
 
cancelToken.cancel();
 

// 入口
function main(){
    let cancel = new CancelToken();
    cancel.CancelAfter(10 * 1000);//10 秒
    cancel.register(x=> console.log(`token a cancel 了`))
    doLongStuff(cancel)
    .then(()=>console.log(`没有取消`))
    .cache(e=> console.log(`最终还是取消了`))
}
 
function doLongStuff(cancelToken:ICancelToken):Promise<void>{
    // 我们里面要求 5秒就取消
    let runningTime = (Math.random() * 20); //随机0-20秒
    let cancel = new Cancel();
    setTimeout(()=> cancel.cancel(), 5000);
    cancel.linkeToken(cancelToken);
    //这里里面的 cancel 跟外面的没有关系， 里面的取消，并不会导致外面的 取消,但外面的 token取消，会触发里面的取消
 
 
    return new Promise<void>((resolve,reject)=>{
        setTimeout(()=>{
            // 检查自己的token,不要管别的
            if(cancel.isCanceled){ 
                reject(`canceled`)
            }
            else{
                resove();
            }
        }, runningTime * 1000)
        
    })
}

httpClient.Get("/api/get")
.cache(e=>{
  if(e instanceof StatusCodeError){
    ....
  }
  else if (e instanceof CancelError){
    ...
  }
})

import {
    HttpClientIntercepter,
    IntercepterRequestContext,
    IntercepterResponseContext,
    IntercepterDelegate,
    TaskSource,
    Task
} from "uni-httpclient";
export class MyDataIntercepter implements HttpClientIntercepter {
    constructor() { }
 
    async handle(request: IntercepterRequestContext, next: IntercepterDelegate): Promise<IntercepterResponseContext> {
        await Task.delay(2000); // 延时2秒
        
        if(request.url == "/api/api1"){
            return {
                httpClient: null ,
                httpClientHander: null,
                statusCode: 200,
                data: { /*您的数据*/ },
                header: {},
                pipeOptions:request.pipeOptions
            }
        }
        // 只要你不调用 next ， 就不会往下执行，你随时可以阻止往下执行
    }
}
 
// 使用
 
HttpClient.setupDefaults({ 
  retryCount: 1,
  timeout:15,
  statusCodeError:true,
  baseUrl:"https://localhost:5001"
 });
 HttpClient.intercepters.unshift(new MyDataIntercepter()) // 使用unshif 将此拦截器放在最开始的时候