angularjs - Una definición de tipo para cubrir las propiedades de tipos primitivos y genéricos sin unirlos

Este es el patrón que requiere que defina dos tipos que me gustaría refactorizar/consolidar:

...
.then((result1: any) => {
    let promises = {
       one: $q.when(val1),
       two: $q.when(val2)
    };
    return $q.all(promises);
})
.then((resolvedPromises: any) => {
    // use
    resolvedPromises.one...
    resolvedPromises.two
});

Me gustaría definir el tipo de promises y resolvedPromises, pero como están relacionados con tipos, me gustaría definir un solo tipo (probablemente genérico) en lugar de definir dos tipos con una definición similar.

Así que en lugar de:

public interface ResultingType {
    [id: string]: any,
    one: Something1,
    two: Something1
}

public interface PromisingType {
    [id: string]: ng.IPromise<any>,
    one: ng.IPromise<Something1>,
    two: ng.IPromise<Something2>
}

El problema es que desde la perspectiva del tipo genérico habitual proporcionamos el tipo más interno en el que se va a inyectar, pero en mi caso necesito de alguna manera definir el tipo externo ya sea siendo ng.IPromise<> o en realidad nada.

Tampoco quiero terminar con un solo tipo que permita ambos tipos:

public interface ConsolidatedType {
    [id: string]: any | ng.IPromise<any>,
    one: Something1 | ng.IPromise<Something1>,
    two: Something2 | ng.IPromise<Something2>
}

Esto permitiría mezclar y combinar en lugares no válidos. Así que eso no es posible. ¿Hay alguna otra manera de tener realmente un solo tipo sin repetición de código que solo envuelva tipos en promesas?

Respuesta #1

Qué tal:

interface BaseType<T, S> {
    [id: string]: T;
    one: S;
    two: S;
}

Y luego:

...
.then((result1: any) => {
    let promises = {
       one: $q.when(val1),
       two: $q.when(val2)
    } as BaseType<ng.IPromise<any>, ng.IPromise<Something1>>;
    return $q.all(promises);
})
.then((resolvedPromises: BaseType<any, Something1>) => {
    // use
    resolvedPromises.one...
    resolvedPromises.two
});

También puedes crear "atajos":

interface PromiseType extends BaseType<ng.IPromise<any>, ng.IPromise<Something1>> {}

interface ValueType extends BaseType<any, Something1> {}

Y luego:

...
.then((result1: any) => {
    let promises = {
       one: $q.when(val1),
       two: $q.when(val2)
    } as PromiseType;
    return $q.all(promises);
})
.then((resolvedPromises: ValueType) => {
    // use
    resolvedPromises.one...
    resolvedPromises.two
});