Как написать неуниверсальный тип для конструктора универсального класса в машинописном тексте или использовать универсальный тип с служебными типами?

Для начала небольшое отступление. Будет гораздо проще сделать RepositoryDescriptorобобщенным в возвращаемом типе конструктора T:

type RepositoryDescriptor<T extends Base<any, any>> = {
    ctor: () => (new (options: RepositoryOptions<any, any>) => T)
}

и тогда вы можете написать Registry в виде аргументов типа RepositoryDescriptor в его наборе repositories. Таким образом, вам не придется использовать условные типы для их последующего восстановления:

class Registry<R extends { [key: string]: Base<any, any> }> {
    repositories: { [K in keyof R]: RepositoryDescriptor<R[K]> }

    constructor(registry: { [K in keyof R]: RepositoryDescriptor<R[K]> }) {
        this.repositories = registry
    }

    get<K extends string & keyof R>(key: K, v: R[K]['v']) { // return type?
        let ctor = this.repositories[key].ctor();
        return new ctor({ r: this, v, n: key });
    }
}

Поэтому мы используем сопоставленный тип для преобразования R в тип repositories, и тогда вам не нужно будет отменять его позже. Просто напишите R[K] вместо Repository<R[K]>.

Это не обязательно, но с этим проще справиться.

Основная проблема, с которой вы столкнулись, — это попытка применить аргумент нового типа к произвольному универсальному классу. Но TypeScript не позволяет таким образом абстрагироваться от универсальных типов. Вы можете абстрагироваться только над обычными типами данных, самого низкого вида типа:

// you can do this
type Foo<T extends unknown> = ⋯T⋯ 
type Bar = Foo<string>;

Вы не можете поднять это на один уровень и поговорить о дженериках, например

// you can't do this
type Baz<F extends UnknownGeneric> = ⋯F<string>⋯
type Qux = Baz<Foo> 

Вы не можете сказать, что F является «универсальным», а затем написать F<string> внутри тела Baz. И вы не можете перейти от Foo к Baz, потому что Foo сам по себе не является первоклассной вещью. Писать можно Foo<string>, но не только Foo.

Для этого потребуются типы более высокого рода, как того требует давняя открытая проблема GitHub https://github.com/microsoft/TypeScript/issues/1213.

Так что нет прямого способа сказать

class Registry<R extends { [key: string]: UnknownGeneric & Base<any, any> }> {
    //             that's not a thing ----^^^^^^^^^^^^^^
    repositories: { [K in keyof R]: RepositoryDescriptor<R[K]> }

    constructor(registry: { [K in keyof R]: RepositoryDescriptor<R[K]> }) {
        this.repositories = registry
    }

    get<K extends string & keyof R>(key: K, v: R[K]['v']): R[K]<this> {
    // that's not a thing -------------------------------------^^^^^^
        let ctor = this.repositories[key].ctor();
        return new ctor({ r: this, v, n: key });
    }
}

потому что нельзя сказать, что R[K] будет «универсальным». Но если бы мы могли, идея состоит в том, что R[K] был бы общим подтипом Base, который принимает один аргумент типа для Registry<?>, и мы бы использовали полиморфный этот тип, чтобы представить, что мы помещаем this вместо r .

Существуют различные обходные пути и подходы, позволяющие выражать типы более высокого рода в TypeScript. Одна из версий, которую я видел, состоит в том, чтобы составить список универсальных типов, к которым вы хотите иметь возможность применять аргументы типа, сохраняя их в интерфейсе, чтобы вы могли объединять новые члены, когда захотите.

Вот как это может выглядеть на этом примере:

// list of generic subclasses of Base, initially empty
interface ClassList<R extends Registry<any>> { }

// produce the equivalent of T<R> if T were a higher kinded type
type Apply<T, R extends Registry<any>> =
    { [K in keyof ClassList<R>]:
        T extends ClassList<any>[K] ? ClassList<R>[K] : never
    }[keyof ClassList<R>]

class Registry<R extends { [key: string]: Base<any, any> }> {
    // ⋮    
    get<K extends string & keyof R>(key: K, v: R[K]['v']): Apply<R[K], this> {
        let ctor = this.repositories[key].ctor();
        return new ctor({ r: this, v, n: key }) as Base<any, any> as Apply<R[K], this>;
    }
}

Итак, если это сработает, то Apply<R[K], this> будет эквивалентно задуманному R[K]<this>. За исключением того, что R[K] будет каким-то конкретным подтипом Base<any, any> и не будет универсальным, поэтому это будет больше похоже на «заменить аргумент типа в R[K] на this» вместо «передать в общий R[K] аргумент типа this».

Давайте проверим это:

class A<R> extends Base<R, boolean> { a = 1 }
interface ClassList<R> { A: A<R> } // <-- merged in

class B<R> extends Base<R, number> { b = 2 }
interface ClassList<R> { B: B<R> } // <-- merged in

Итак, ClassList<R> содержит два члена: один типа A<R> и один типа B<R>. И теперь, когда мы используем это для создания реестра:

const registry = new Registry({
    A: {
        ctor: () => A
    },
    B: {
        ctor: () => B
    },
})

let a = registry.get('A', true)
//  ^? let a: A<Registry<{ A: A<any>; B: B<any>; }>>
let b = registry.get('B', 50)
//  ^? let b: B<Registry<{ A: A<any>; B: B<any>; }>>
let c = a.registry.get('C', true) // error!
let d = b.registry.get('C', true) // error!

Вы видите желаемое поведение. Тип возвращаемого значения registry.get('A', true) — A<Registry<{A: A<any>, B: B<any>}>>, и это вся необходимая информация. Эти любые ничему не повредят, потому что они будут заменены на this всякий раз, когда вы углубляетесь в get().

Итак, это работает. Это не обязательно лучший или даже хороший подход, есть и другие подходы, упомянутые в microsoft/TypeScript#1213, которые вы, возможно, захотите изучить. Однако до тех пор, пока мы не получим настоящие типы высшего рода в TypeScript, вам придется либо сдаться, либо обойти это.

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