Пересечение и создание подклассов для сужения типа свойства Record<string, Any>`

Ваша последняя попытка пока самая близкая, но функция doSomething мешает сделать что-либо. Могу ли я предложить следующее:

declare class Foo<U = Record<string, any>> {
    readonly user_data: U

    // other members including private
    private __secret(): void;
}

declare function doSomething<U>(foo: Foo<U>): void;

declare const foo: Foo<{
    a: string,
    b: number,
}>;

doSomething(foo);

Этот подход упрощает ситуацию за счет того, что функция doSomething становится универсальной. Однако он по-прежнему работает, поскольку Foo имеет тип по умолчанию для user_data.

Идеальным решением здесь было бы, если бы восходящий поток Foo использовал тип объекта или даже пустой тип объекта {} вместо Record<string, any>. Тип Record<string, any> эквивалентен {[k: string]: any}, строке индексной подписи, где каждое свойство имеет тип any и, следовательно, позволяет индексировать его с помощью любого ключа и делать что-либо с полученным свойством. Это означает, что он невероятно либерален и небезопасен по типу.

Кроме того, если вы хотите сузить этот тип, было бы хорошо, если бы восходящий Foo был универсальным в типе T свойства user_data. Этот тип может быть ограничен до object и даже по умолчанию до object, например:

declare class Foo<T extends object = object> {
    readonly user_data: T
    private __secret(): void;
}
        
declare function doSomething(foo: Foo): void;

declare const foo: Foo<{ a: string, b: number }>;
foo.user_data.a = "hello"; // ok
foo.user_data.a = 1; // error
foo.user_data.c = "hello"; // error
doSomething(foo); // ok

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

Если class имеет частные или защищенные члены и вы хотите сузить одно из его свойств, не «видя» тип свойства из базового класса, то единственный работоспособный вариант — использовать наследование через расширения либо как интерфейс или как объявление подкласса. То есть, учитывая

declare class Foo {
    readonly user_data: Record<string, any>
    private __secret(): void;
}
declare function doSomething(foo: Foo): void;

ты можешь написать

interface MyFoo<T extends object> extends Foo {
    readonly user_data: T
}

а затем используйте MyFoo<T> вместо Foo там, где это необходимо:

declare const foo: MyFoo<{ a: string, b: number }>;
foo.user_data.a = "hello"; // ok
foo.user_data.a = 1; // error
foo.user_data.c = "hello"; // error
doSomething(foo); // ok

Другие попытки добиться такого поведения сталкиваются с различными проблемами.

Расширение класса/интерфейса, которое сужает свойства, ведет себя аналогично пересечению части с суженными свойствами с частью базового класса без этих свойств, поэтому interface X extends Y { z: Z } аналогично type X = Omit<Y, "z"> & { z: Z } использованию типа утилиты Omit . Но вы не можете сохранить свойства private или protected с помощью Omit или любого сопоставленного типа. По адресу microsoft/TypeScript#35416 есть запрос на открытие функции, позволяющий это сделать, но это не является частью языка. На данный момент единственный способ сохранить эти свойства — это наследование.

Часто пересечение все же может сойти с рук, если предположить, что type X = Y & {z: Z} ведет себя как Omit<Y, "z"> & {z: Z}, при условии, что если Y имеет свойство z, то результирующее свойство z типа Y["z"] & Z будет иметь тип, эквивалентный Z, и вы можете игнорировать Y["z"] тип. Если Z является сужением Y["z"], то оно должно быть эквивалентным, верно? Верно? Ну, часто это: string & "a"is just"a", and {} & {p: string}is just{p: string}. But sometimes it isn't completely equivalent. And since Record<string, Any>is so permissive and not type safe, you can't ignore it when intersecting withZ. The type Record<string, Any> & Zis going to look a lot likeRecord <строка, любой>`.

Так что если Omit<Y, "z"> & {z: Z} не работает, и Y & {z: Z} не работает, то нужно по сути отказаться от перекрестков. Вам нужно расширение интерфейса/класса. А поскольку для такого расширения требуются статически известные ключи, вы не можете написать полностью повторно используемый вспомогательный тип, например interface HUD<C, T> extends C {user_data: T}, где C — параметр универсального типа. Вам нужно написать interface MyFoo<T> extends Foo {user_data: T} и interface MyBar<T> extends Bar {user_data: T} и т. д.

Это прискорбно, но вы не сможете сделать ничего лучше, не устраняя проблемы на предыдущем этапе.

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