/* eslint-disable ts/no-explicit-any */

/** 泛型组件工具 */
import type { AllowedComponentProps, ComponentCustomProps, ShallowUnwrapRef, VNode, VNodeProps } from 'vue'

/**
 * 简单类型工具
 */

/** 并集转交集 */
export type Union2Intersection<Union> = (Union extends any ? (argument: Union) => void : never) extends (
    argument: infer I,
) => void
    ? I
    : never

type Union2UoF<Union> = Union extends any ? (argument: Union) => void : never
type Union2IoF<Union> = Union2Intersection<Union2UoF<Union>>

type Firs2fUnion<Union> = Union2IoF<Union> extends { (argument: infer T): void } ? T : never

type Union2TupleRecurser<Union, Tuple extends any[]> = [
    Firs2fUnion<Union>,
    Exclude<Union, Firs2fUnion<Union>>,
] extends [infer First, ...infer Lasts]
    ? ([First] extends [never]
            ? Tuple
            : Union2TupleRecurser<Lasts, [First, ...Tuple]>)
    : never

/** 并集转元组 */
export type Union2Tuple<Union> = Union2TupleRecurser<Union, []>

/** vue 组件助手 */
export type PublicProps = VNodeProps & AllowedComponentProps & ComponentCustomProps

export type GenericExposed<Ex extends {} = {}> = ShallowUnwrapRef<Ex>

export type GenericCtx<P, E, S = {}, Ex extends {} = {}, A = any> = {
    props: P & PublicProps
    emit: E
    attrs: A
    slots: S
    expose(exposed: GenericExposed<Ex>): void
}

export type GenericReturn<P, E, S = {}, Ex extends {} = {}, A = any> = VNode & {
    __ctx?: GenericCtx<P, E, S, Ex, A>
}

/** 或许是 Promise */
export type MaybePromise<T> = T | Promise<T>

/** 可等待的 */
export type Awaitable<T> = T | PromiseLike<T>

/** 或许是 Array */
export type MaybeArray<T> = T | Array<T>

/** 或许是 ArrayLike */
export type MaybeArrayLike<T> = T | ArrayLike<T>

/** 或许是 Iterable */
export type MaybeIterable<T> = T | Iterable<T>

/** 将不可变转换为可变 */
export type Mutable<T> = {
    -readonly [P in keyof T]: T[P]
}

/** 部分键设为必须 */
export type RequiredKeys<T, K extends keyof T = keyof T> = T & {
    [P in K]-?: NonNullable<T[P]>
}

/** 部分键设为可选 */
export type PartialKeys<T, K extends keyof T = keyof T> = Omit<T, K> & {
    [P in K]?: T[P]
}

/** 映射键名称 */
export type MapObjectProps<T extends {}, K extends string, P extends 'front' | 'behind'>
    = P extends 'front' ? {
        [Key in (keyof T) & string as `${K}${Capitalize<Key>}`]: T[Key]
    } : {
        [Key in (keyof T) & string as `${Key}${Capitalize<K>}`]: T[Key]
    }

/** 提取数组项类型 */
export type ItemTypeOf<T> = T extends Array<(infer R)> ? R : never

/** 假值类型 */
export type Falsely = false | null | undefined | '' | 0