Array<string>の値から動的に型を生成する事は可能でしょうか？

Question

const currencies = ["CNY", "EUR", "GBP", "JPY", "KRW", "USD"] as const;
type Currency = typeof currencies[number]; // 'CNY' | 'EUR' | 'GBP' | 'JPY' | 'KRW' | 'USD'

上記のように定義する事で配列の値から型を生成する事ができます
これを動的に生成する方法はあるでしょうか？

interface AAAA {
  [key: string] : Array<string> | Array<boolean>;
}

type BBBB<T> = {
  [P in keyof T]: T[P] extends Array<string> ? string : boolean  // ★stringの場合 値から動的に型を生成したい
}

function func<T extends AAAA>(input : T): BBBB<T> {
     :
}

const result = func({
  str: ["aa", "bb"],
  bol: [true],
});

たとえば、上記のようにfuncを呼んだときの戻り値BBBB型は以下のようにしたいです

{
    str: 'aa' || 'bb',  //  ★ 現状はstringになるので値から型を生成したい
    bol: boolean,  
}

Answer 1

例えばこのように書いたら

type Input = {
  [key: string]: string[] | boolean[];
};

type UnpackInput<T extends Input> = {
  [K in keyof T]: T[K][number];
};

function unpack<T extends Input>(_input: T): UnpackInput<T> {
  return {} as any;
}

const result = unpack({
  str: ["aa", "bb"],
  bol: [true],
});

こうなることを期待しますが、

result.str; // (property) str: "aa" | "bb" <- こうはならない
result.bol; // (property) bol: true

実際はstrの中身が不変であることを保証していないため、stringとして扱われてしまいます。

result.str; // (property) str: string <- stringにされてしまう
result.bol; // (property) bol: true

一番シンプルな方法は引数の配列の型をreadonly修飾子でReadonlyArrayにし、関数を呼び出す際に配列にas constと書き加えることです。

type Input = {
  [key: string]: readonly string[] | readonly boolean[];
};

type UnpackInput<T extends Input> = {
  [K in keyof T]: T[K][number];
};

function unpack<T extends Input>(_input: T): UnpackInput<T> {
  return {} as any;
}

const result = unpack({
  str: ["aa", "bb"] as const,
  bol: [true],
});

result.str; // (property) str: "aa" | "bb" <- "aa" | "bb" を残してくれる
result.bol; // (property) bol: true

しかし関数を呼び出す度にas constと書き加えるのは面倒ですし、万が一書き忘れたとしてもコンパイラは注意してくれません。そこで、もう一つの選択肢としてtscの特性を悪用活用したNarrow型ハックと呼ばれる方法があります。

/** Narrow型の実装の一例 */
type Narrow<T> = { [K in keyof T]: Narrow<T[K]> } | T;

Narrow型を使うことでオブジェクトの中身にreadonly修飾子をつけ、呼び出し時にas constアサーションをつけた時のような結果を得ることができます。

type Input = {
  [key: string]: string[] | boolean[];
};

type UnpackInput<T extends Input> = {
  [K in keyof T]: T[K][number];
};

function unpack<T extends Input>(input: Narrow<T>): UnpackInput<T> {
  return {} as any;
}

const result = unpack({
  str: ["aa", "bb"],
  bol: [true],
});

result.str; // (property) str: "aa" | "bb" <- "aa" | "bb" を残してくれる
result.bol; // (property) bol: true

黒魔術に抵抗がなければ後者をお勧めしますが、そうでなければeslint用のルールを書いてas constを繰り返し書く方法が良いでしょう。

追記

上記Narrow型は例としてのシンプルさを優先するため、あらゆるエッジケースについて一才の考慮をしていません。実際の開発ではmillsp/ts-toolbeltにあるような真面目な実装を用いることをお勧めします。

Comments

[fijino]

ご回答ありがとうございます
おかげ様で解決できましたが、まだ十分理解できていないので後は自分で調べて理解したいと思います
ありがとうございました