[typescript] 유형 매핑시 일반 속성 관련 문제

이것은 흥미로운 문제입니다. Typescript는 일반적으로 조건부 유형의 일반 유형 매개 변수와 관련하여 많은 것을 할 수 없습니다. 평가에 extends유형 매개 변수가 포함 된 것으로 판단되면 평가를 연기합니다 .

특수한 유형 관계, 즉 평등 관계 (확장 관계가 아님) 를 사용하기 위해 유형 스크립트를 얻을 수있는 경우 예외가 적용됩니다 . 평등 관계는 컴파일러에 대해 이해하기 간단하므로 조건부 유형 평가를 연기 할 필요가 없습니다. 일반 제약 조건은 형식 평등이 사용되는 컴파일러의 몇 안되는 장소 중 하나입니다. 예를 보자.

function m<T, K>() {
  type Bad = T extends T ? "YES" : "NO" // unresolvable in ts, still T extends T ? "YES" : "NO"

  // Generic type constrains are compared using type equality, so this can be resolved inside the function 
  type Good = (<U extends T>() => U) extends (<U extends T>() => U) ? "YES" : "NO" // "YES"

  // If the types are not equal it is still un-resolvable, as K may still be the same as T
  type Meh = (<U extends T>()=> U) extends (<U extends K>()=> U) ? "YES": "NO"
}

운동장 링크

이 동작을 활용하여 특정 유형을 식별 할 수 있습니다. 이제 이것은 확장 유형 일치가 아닌 정확한 유형 일치이며 정확한 유형 일치가 항상 적합한 것은 아닙니다. 그러나 이후Action 함수 서명일 뿐이 정확한 형식 일치가 충분할 수 있습니다.

다음과 같이 더 간단한 함수 시그니처와 일치하는 유형을 추출 할 수 있는지 확인하십시오 (v: T) => void.

interface Model<T> {
  value: T,
  other: string
  action: (v: T) => void
}

type Identical<T, TTest, TTrue, TFalse> =
  ((<U extends T>(o: U) => void) extends (<U extends TTest>(o: U) => void) ? TTrue : TFalse);

function m<T>() {
  type M = Model<T>
  type KeysOfIdenticalType = {
    [K in keyof M]: Identical<M[K], (v: T) => void, never, K>
  }
  // Resolved to
  // type KeysOfIdenticalType = {
  //     value: Identical<T, (v: T) => void, never, "value">;
  //     other: "other";
  //     action: never;
  // }

}

운동장 링크

위의 유형 KeysOfIdenticalType은 필터링에 필요한 것과 비슷합니다. 의 경우 other속성 이름이 유지됩니다. 의 경우 action속성 이름이 지워집니다. 주위에 하나의 성가신 문제가 있습니다 value. 이후 value형이고 T, 그 소소를 확인할 수없는 것이다 T하고, (v: T) => void동일하지 않은 (사실들이 아니더라도 좋다).

우리는 여전히 다음 value과 같은 것을 결정할 수 있습니다 T: 유형의 속성에 T대해서는이 검사 (v: T) => void와 교차합니다 never. 와의 모든 교차점 never은로 쉽게 해결할 수 never있습니다. 그런 다음 T다른 신원 확인을 사용하여 유형의 속성을 다시 추가 할 수 있습니다 .

interface Model<T> {
  value: T,
  other: string
  action: (v: T) => void
}

type Identical<T, TTest, TTrue, TFalse> =
  ((<U extends T>(o: U) => void) extends (<U extends TTest>(o: U) => void) ? TTrue : TFalse);

function m<T>() {
  type M = Model<T>
  type KeysOfIdenticalType = {
    [K in keyof M]:
      (Identical<M[K], (v: T) => void, never, K> & Identical<M[K], T, never, K>) // Identical<M[K], T, never, K> will be never is the type is T and this whole line will evaluate to never
      | Identical<M[K], T, K, never> // add back any properties of type T
  }
  // Resolved to
  // type KeysOfIdenticalType = {
  //     value: "value";
  //     other: "other";
  //     action: never;
  // }

}

운동장 링크

최종 솔루션은 다음과 같습니다.

// Filters out an object, removing any key/values that are of Action<any> type
type State<Model extends object, G = unknown> = Pick<Model, {
    [P in keyof Model]:
      (Identical<Model[P], Action<Model, G>, never, P> & Identical<Model[P], G, never, P>)
    | Identical<Model[P], G, P, never>
  }[keyof Model]>;

// My utility function.
type Action<Model extends object, G = unknown> = (data: State<Model, G>) => State<Model, G>;


type Identical<T, TTest, TTrue, TFalse> =
  ((<U extends T>(o: U) => void) extends (<U extends TTest>(o: U) => void) ? TTrue : TFalse);

interface MyModel<T> {
  value: T; // ? a generic property
  str: string;
  doSomething: Action<MyModel<T>, T>;
  method() : void
}


function modelFactory<T>(value: T): MyModel<T> {
  return {
    value,
    str: "",
    method() {

    },
    doSomething: data => {
      data.value; // ok
      data.str //ok
      data.method() // ok 
      data.doSomething; // Does not exist ?
      return data;
    }
  };
}

/// Still works for simple types
interface MyModelSimple {
  value: string;
  str: string;
  doSomething: Action<MyModelSimple>;
}


function modelFactory2(value: string): MyModelSimple {
  return {
    value,
    str: "",
    doSomething: data => {
      data.value; // Ok
      data.str
      data.doSomething; // Does not exist ?
      return data;
    }
  };
}

운동장 링크

참고 : 여기서 제한 사항은 하나의 유형 매개 변수에서만 작동한다는 것입니다 (아마도 더 많이 적용 할 수 있음). 또한 API는 모든 소비자에게 약간 혼란 스럽기 때문에 이것이 최선의 해결책이 아닐 수도 있습니다. 아직 확인하지 않은 문제가있을 수 있습니다. 당신이 발견하면 알려주세요 ?

답변

type KeysOfNonType<A extends object, B> = {
  [K in keyof A]-?: A[K] extends B ? never : K
}[keyof A];

// CHANGE: use `Pick` instead of `Omit` here.
type State<Model extends object> = Pick<Model, KeysOfNonType<Model, Action<any>>>;

type Action<Model extends object> = (data: State<Model>) => State<Model>;

interface MyModel<T> {
  value: T;
  doSomething: Action<MyModel<T>>;
}

function modelFactory<T>(value: T): MyModel<T> {
  return {
    value,
    doSomething: data => {
      data.value; // Now it does exist ?
      data.doSomething; // Does not exist ?
      return data;
    }
  } as MyModel<any>; // <-- Magic!
                     // since `T` has yet to be known
                     // it literally can be anything
}

{
  value,
  count: 1,
  transform: (data: Partial<Thing<T>>) => {
   ...
  }
}

interface Thing<T> {
  value: T;
  count: number;
  transform: (data: Omit<Thing<T>, 'transform'>) => void; // here the argument type is Thing without transform
}

// ? the factory function accepting the generic
function makeThing<T>(value: T): Thing<T> {
  return {
    value,
    count: 1,
      transform: data => {
        data.count; // exist
        data.value; // exist
    },
  };
}