// never 类型
const fn: () => never = () => throw new Error();

export const http = async (
  endpoint: string,
  { data, token, headers, ...customConfig }: Config
) => {
  const config = {
    method: "GET",
    headers: {
      Authorization: token ? `Bearer ${token}` : "",
      "Content-Type": data ? "application/json" : "",
    },
    ...customConfig,
  };
  if (config.method.toLowerCase() === "GET") {
    endpoint += qs.stringify(data);
  } else {
    config.body = JSON.stringify(data || {});
  }
  return window
    .fetch(`${apiUrl}/${endpoint}`, config)
    .then(async (response) => {
      if (response.status === 401) {
        await auth.logout();
        window.location.reload();
        return Promise.reject({ message: "请重新登陆" });
      }
      const data = await response.json();
      if (response.ok) {
        return data;
      } else {
        return Promise.reject(data);
      }
    });
};

// 一个函数如果想要使用其他hook的话，它本身就需要是一个hook。
export const useHttp = () => {
  const { user } = useAuth();
  return ([endpoint, config]: [string, Config]) =>
    http(endpoint, { ...config, token: user?.token });
};

// 可以看到 useHttp 和 http 返回的函数的传参其实是一致的。所以传参可以写成下面👇这种形式。
export const useHttp = () => {
  const { user } = useAuth();
  return ([endpoint, config]: Parameters<typeof http>) =>
    http(endpoint, { ...config, token: user?.token });
};

type Parameters<T extends (...args: any) => any> = T extends (
  ...args: infer P
) => any
  ? P
  : never;

type Person = {
  name: string;
  age: number;
  sex: string;
}

const xiaoMing: Partial<Person> ={}

// Omit删除泛型对象的指定属性后的类型。
const shenMiRen: Omit<Person, 'name' ｜ 'age'> ={
  sex:'男'
}

// Partical 的实现
/**
 * Make all properties in T optional
 */
type Partial<T> = {
    [P in keyof T]?: T[P];
};

keyof Person = 'name' | 'age' | 'sex';

// Omit 的实现
/**
 * Construct a type with the properties of T except for those in type K.
 */
type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;

// Pick 的实现
/**
 * From T, pick a set of properties whose keys are in the union K
 */
type Pick<T, K extends keyof T> = {
  [P in K]: T[P];
};

// Exclude 的实现
/**
 * Exclude from T those types that are assignable to U
 */
type Exclude<T, U> = T extends U ? never : T;

// 限制入参必须是键值对
export const clearObject = (obj: { key: string; value: unknown }) => {
  // ...
};