Сужение возвращаемого типа из общего дискриминируемого объединения в TypeScript

для этого требуется изменения в TypeScript работать точно так, как задано в вопросе.

если классы могут быть сгруппированы как свойства одного объекта, то принятый ответ также может помочь. Я люблю Unionize<T> трюк там.

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

class RedShape {
  color: 'Red'
}

class BlueShape {
  color: 'Blue'
}

type Shapes = RedShape | BlueShape;

type AmIRed = Shapes & { color: 'Red' };
/* Equals to

type AmIRed = (RedShape & {
    color: "Red";
}) | (BlueShape & {
    color: "Red";
})
*/

/* Notice the last part in before:
(BlueShape & {
  color: "Red";
})
*/
// Let's investigate:
type Whaaat = (BlueShape & {
  color: "Red";
});
type WhaaatColor = Whaaat['color'];

/* Same as:
  type WhaaatColor = "Blue" & "Red"
*/

// And this is the problem.

еще одна вещь, которую вы можете сделать, это передать фактический класс функции. Вот такой сумасшедший пример:

declare function filterShape<
  TShapes,  
  TShape extends Partial<TShapes>
  >(shapes: TShapes[], cl: new (...any) => TShape): TShape;

// Doesn't run because the function is not implemented, but helps confirm the type
const amIRed = filterShape(new Array<Shapes>(), RedShape);
type isItRed = typeof amIRed;
/* Same as:
type isItRed = RedShape
*/

проблема здесь в том, что вы не можете получить значение color. Ты можешь!--9-->, но это всегда будет неопределенным, потому что значение применяется только в конструкторе. RedShape составляется:

var RedShape = /** @class */ (function () {
    function RedShape() {
    }
    return RedShape;
}());

и даже если у вас:

class RedShape {
  color: 'Red' = 'Red';
}

это компилируется в:

var RedShape = /** @class */ (function () {
    function RedShape() {
        this.color = 'Red';
    }
    return RedShape;
}());

и в вашем реальном примере конструкторы могут иметь несколько параметров и т. д., Поэтому создание экземпляра также может быть невозможно. Не говоря уже о его не работа для интерфейсов тоже.

возможно, Вам придется вернуться к глупому как:

class Action1 { type: '1' }
class Action2 { type: '2' }
type Actions = Action1 | Action2;

declare function ofType<TActions extends { type: string },
  TAction extends TActions>(
  actions: TActions[],
  action: new(...any) => TAction, type: TAction['type']): TAction;

const one = ofType(new Array<Actions>(), Action1, '1');
/* Same as if
var one: Action1 = ...
*/

или в doSomething текст:

declare function doSomething<TAction extends { type: string }>(
  action: new(...any) => TAction, type: TAction['type']): TAction;

const one = doSomething(Action1, '1');
/* Same as if
const one : Action1 = ...
*/

как упоминалось в комментарии к другому ответу, в TypeScript есть проблема для исправления проблемы вывода. Я написал комментарий, ссылающийся на объяснение этого ответа и предоставляющий пример более высокого уровня проблемы здесь.

к сожалению, вы не можете достичь этого поведения, используя тип объединения (т. е. type MyActions = ExampleAction | AnotherAction;).

если у нас есть значение с типом объединения, мы можем получить доступ только к членам, общим для всех типов в объединении.

тем не менее, ваше решение отлично. Вам просто нужно использовать этот способ, чтобы определить тип, который вам нужен.

const result2 = items.doSomething<ExampleAction>('Example');

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

немного подробнее о настройке, но мы можем достичь желаемого API с помощью поиска типов:

interface Action {
  type: string;
}

interface Actions {
  [key: string]: Action;
}

interface ExampleAction extends Action {
  type: 'Example';
  example: true;
}

interface AnotherAction extends Action {
  type: 'Another';
  another: true;
}

type MyActions = {
  Another: AnotherAction;
  Example: ExampleAction;
};

declare class Example<T extends Actions> {
  doSomething<K extends keyof T, U>(key: K): T[K];
}

const items = new Example<MyActions>();

const result1 = items.doSomething('Example');

console.log(result1.example);

начиная с TypeScript 2.8, вы можете выполнить это с помощью условных типов.

// Narrows a Union type base on N
// e.g. NarrowAction<MyActions, 'Example'> would produce ExampleAction
type NarrowAction<T, N> = T extends { type: N } ? T : never;

interface Action {
    type: string;
}

interface ExampleAction extends Action {
    type: 'Example';
    example: true;
}

interface AnotherAction extends Action {
    type: 'Another';
    another: true;
}

type MyActions =
    | ExampleAction
    | AnotherAction;

declare class Example<T extends Action> {
    doSomething<K extends T['type']>(key: K): NarrowAction<T, K>
}

const items = new Example<MyActions>();

// Inferred ExampleAction works
const result1 = items.doSomething('Example');

Примечание: кредит @jcalz для идеи типа NarrowAction из этого ответа https://stackoverflow.com/a/50125960/20489