// ============================================================================
// Helpers
// ============================================================================

/**
 * @description Strict version of builtin `Extract`, `U` must be subset of `T`.
 */
export type StrictExtract<T, U extends T> = Extract<T, U>
/**
 * @description Strict version of builtin `Exclude`, `U` must be subset of `T`.
 */
export type StrictExclude<T, U extends T> = Exclude<T, U>

// ============================================================================
// Manipulation
// ============================================================================

/**
 * @description Get the shared members of two union types.
 *
 * @example
 *   ```
 *   // Expect: "2" | "3"
 *   UnionIntersection<'1' | '2' | '3', '2' | '3' | '4'>;
 *
 *   // Expect: () => void
 *   UnionIntersection<string | number | (() => void), Function>;
 *   ```
 */
export type UnionIntersection<UnionA, UnionB> = UnionA extends UnionB ? UnionA : never

/**
 * @description Get the members that exist in the first union but not in the second.
 *
 * @example
 *   ```
 *   // Expect: "1"
 *   UnionDifference<'1' | '2' | '3', '2' | '3' | '4'>;
 *
 *   // Expect: string | number
 *   UnionDifference<string | number | (() => void), Function>;
 *   ```
 */
export type UnionDifference<UnionA, UnionB> = UnionA extends UnionB ? never : UnionA

/**
 * @description Get the complement of a sub-union within a larger union.
 *
 * @example
 *   ```
 *   // Expect: "1"
 *   UnionComplement<'1' | '2' | '3', '2' | '3'>;
 *   ```
 */
export type UnionComplement<Union, SubUnion extends Union> = UnionDifference<Union, SubUnion>

/**
 * @description Get the members that belong to exactly one of the two unions.
 *
 * @example
 *   ```
 *   // Expect: "1" | "4"
 *   UnionSymmetricDifference<'1' | '2' | '3', '2' | '3' | '4'>;
 *   ```
 */
export type UnionSymmetricDifference<UnionA, UnionB> = UnionDifference<
  UnionA | UnionB,
  UnionA & UnionB
>

/**
 * @description Get one stable trailing member from a union.
 *
 * @example
 *   ```
 *   // Expect: "c"
 *   type Result = LastOfUnion<'a' | 'b' | 'c'>
 *   ```
 */
export type LastOfUnion<Union> =
  UnionToIntersection<Union extends unknown ? (x: Union) => void : never> extends (
    x: infer L,
  ) => void
    ? L
    : never

/**
 * @description Remove one trailing member from a union.
 *
 * @example
 *   ```
 *   // Expect: "a" | "b"
 *   type Result = UnionPop<'a' | 'b' | 'c'>
 *   ```
 */
export type UnionPop<U> = Exclude<U, LastOfUnion<U>>

// ============================================================================
// Conversion
// ============================================================================

/**
 * @description Convert a union type to an intersection type.
 *
 * @example
 *   ```
 *   // Expect: { name: string } & { age: number } & { visible: boolean }
 *   UnionToIntersection<{ name: string } | { age: number } | { visible: boolean }>
 *   ```
 *
 * @see {@link https://stackoverflow.com/a/50375286/7381355}
 */
export type UnionToIntersection<Union> = (
  Union extends unknown ? (_: Union) => void : never
) extends (_: infer Result) => void
  ? Result
  : never

type InternalUnionToTuple<U, T extends unknown[]> = [U] extends [never]
  ? T
  : InternalUnionToTuple<Exclude<U, LastOfUnion<U>>, [LastOfUnion<U>, ...T]>
/**
 * @description Convert a union type to a tuple type.
 *
 * @example
 *   ```
 *   // Expect: ["1", "2", "3"]
 *   type Example = UnionToTuple<'1' | '2' | '3'>
 *   ```
 */
export type UnionToTuple<U> = InternalUnionToTuple<U, []>