// ============= Test Cases =============
import type { Equal, Expect } from './test-utils'

type A1 = IsRequiredKey<
  { a: number; b?: string },
  'a'
>;
type B1 = true;
type C1 = Expect<Equal<A1, B1>>;

type A2 = IsRequiredKey<
  { a: number; b?: string },
  'b'
>;
type B2 = false;
type C2 = Expect<Equal<A2, B2>>;

type A3 = IsRequiredKey<
  { a: number; b?: string },
  'b' | 'a'
>;
type B3 = false;
type C3 = Expect<Equal<A3, B3>>;

type A4 = IsRequiredKey<
  { a: undefined; b?: string },
  'a'
>;
type B4 = true;
type C4 = Expect<Equal<A4, B4>>;

type A5 = IsRequiredKey<
  { a: undefined; b: string },
  'a' | 'b'
>;
type B5 = true;
type C5 = Expect<Equal<A5, B5>>;

// ============= Your Code Here =============
// @teamchong
type IsRequiredKey<T, K extends keyof T> =
  Equal<
    { [P in K]: T[P] },
    { [P in K]-?: T[P] }
  >

// @humandetail
type RequiredKeys<T> = keyof {
  [P in keyof T as
    Omit<T, P> extends T
    ? never
    : P
  ]: T[P]
}
type IsRequiredKey<T, K extends keyof T> = Equal<RequiredKeys<T>, K>

// @justBadProgrammer
type IsRequiredKey<
  T extends object,
  K extends keyof T,
  O extends object = { [J in K] : T[J] }
> =
  O extends Required<O>
  ? true
  : false;

// @drylint
type IsRequiredKey<T, K extends keyof T> =
  T[K] extends Required<T>[K]
  ? true
  : false;

// @jiangshanmeta (author of the challenge)
type IsRequiredKey<T, K extends keyof T> =
  (
    K extends keyof T
    ? T extends Required<Pick<T, K>>
      ? true
      : false
    : never
  ) extends true
  ? true
  : false;
  
// ================== NOPE ==================
type IsRequiredKey<T, K extends keyof T> =
  undefined extends T[K]
  ? false
  : true;

type IsRequiredKey<T, K extends keyof T> =
  T[K] | undefined extends T[K]
  ? false
  : true;