Создайте динамический класс и второй тип параметра на основе первого

Проблема в том, что TypeScript не может посмотреть тип MenuElements и увидеть, что для произвольного общего ключа type вы можете написать new MenuElements[type](model) где model — ожидаемый ввод, соответствующий конструктору. Он не видит абстрактной корреляции между type и model. В итоге он расширяется MenuElements[type] до своего ограничения , которое представляет собой объединение typeof Product | typeof Category. А объединения функций/конструкторов требуют пересечений аргументов для безопасного вызова (см. примечания к выпуску TypeScript 3.3, описывающие эту функцию).

Неспособность TypeScript следовать коррелированным объединениям описана в microsoft/TypeScript#30581.

Рекомендуемый подход к решению этой проблемы описан на странице microsoft/TypeScript#47109.

Идея состоит в том, что вам нужно написать тип MenuElements так, чтобы это была явно одна структура для каждого ключа. Вы делаете это, делая его сопоставленным типом . Итак, вам понадобится const MenuElements: { [K in ⋯]: ⋯ } = . И тип свойства этого отображаемого типа должен быть сигнатурой конструкции, которая связывает некоторые конкретные входные данные конструктора, которые зависят от K, с конкретным типом экземпляра, который также зависит от K. Итак, это должно выглядеть так

const MenuElements: { [K in keyof MenuElementsParam]:
    new (arg: MenuElementsParam[K]) => MenuElementsReturn[K]
} = {
    [MenuElement.Products]: Product,
    [MenuElement.Categories]: Category
};

type MenuElementsParam = {
    [MenuElement.Products]: ProductModel;
    [MenuElement.Categories]: CategoryModel;
}

type MenuElementsReturn = {
    [MenuElement.Products]: Product;
    [MenuElement.Categories]: Category;
}

И если вы это сделаете, вы можете использовать MenuElementsParam вместо сложного ModelTypeForNewElement типа позывного для createMenuElement:

function createMenuElement<K extends keyof MenuElementsParam>(
    type: K, model: MenuElementsParam[K]
) {

    const ElementType = MenuElements[type]
    if (!ElementType) {
        throw new Error(`Cannot find the class type of ${type}`);
    }
    return new ElementType(model); // okay, works

}

И если вы проверите подпись вызова, вы увидите, что она возвращается MenuElementsReturn[K]:

/* function createMenuElement<K extends keyof MenuElementsParam>(
     type: K, model: MenuElementsParam[K]): MenuElementsReturn[K] */

Это дает вам поведение, которое вы ищете:

const cat = createMenuElement(MenuElement.Categories, { favorite: true, id: "", name: "" });
//    ^? const cat: Category
const pro = createMenuElement(MenuElement.Products, { age: 123, id: "", name: "" });
//    ^? const pro: Product

Это отвечает на вопрос, но если вы решите добавить еще одно свойство к MenuElements, вам придется внести кучу шаблонных изменений в MenuElementsParam и MenuElementsReturn. Было бы лучше, если бы вы могли просто написать MenuElements, а затем TypeScript вычислил MenuElementsParam и MenuElementsReturn на его основе.

И это действительно возможно, с оговоркой, что вам нужно будет инициализировать MenuElements в другой переменной, чтобы мы могли позже аннотировать тип переменной MenuElements. Итак, давайте оставим исходный MenuElements, но переименуем его:

const _MenuElements = {
    [MenuElement.Products]: Product,
    [MenuElement.Categories]: Category
}

И давайте проверим его тип:

type _MenuElements = typeof _MenuElements;

Отсюда нам нужно вытащить параметры и возвращаемые типы конструкторов. Мы можем сделать это, используя типы утилит ConstructorParameters и InstanceType:

type MenuElementsParam = 
  { [K in keyof _MenuElements]: ConstructorParameters<_MenuElements[K]>[0] }

type MenuElementsReturn = 
  { [K in keyof _MenuElements]: InstanceType<_MenuElements[K]> }

(отметим, что ConstructorParameters дает кортеж всех параметров, но поскольку у вас есть только один и вы хотите получить его, нам нужно индексировать этот кортеж с помощью 0, чтобы получить первый параметр.)

Или мы можем записать их самостоятельно, используя вывод условного типа, именно так в любом случае определяются эти типы утилит:

type MenuElementsParam = { [K in keyof _MenuElements]:
    _MenuElements[K] extends new (arg: infer A) => any ? A : never
}

type MenuElementsReturn = { [K in keyof _MenuElements]:
    _MenuElements[K] extends new (arg: any) => infer R ? R : never
}

Это просто проверка _MenuElements[K] на сигнатуру конструкции new (arg: any) => any) и inferкольцевание интересующего нас фрагмента. Оба определения приводят к типам, эквивалентным версиям, определенным вручную, но теперь, если _MenuElements изменится, они будут меняться автоматически.

Наконец, мы можем аннотироватьMenuElements как тот же сопоставленный тип, что и раньше, но теперь мы инициализируем его значением _MenuElements:

const MenuElements: { [K in keyof _MenuElements]:
    new (arg: MenuElementsParam[K]) => MenuElementsReturn[K]
} = _MenuElements;

И мы закончили. Функция createMenuElement() проверяет типы как вызывающих, так и реализаций.

Детская площадка, ссылка на код