Как конкретизировать сложный тип?

Question

[Aetae]

Допустим есть такой интерфейс(на самом деле он конечно гораздо сложней):

interface Some {
  value: string | string[];
}

Мне нужно получить константу полностью соответствующую этому типу, но конкретизированную по значению. Т.е. можно ли как-то заявить для ts, что структура будет именно такой и меняться не будет?

Если просто указать тип, то работать не будет, т.к. ts считает что структура объекта может измениться как угодно в пределах типа, что логично:

const foo: Some = {
  value: ['a', 'b'] // здесь всегда будет массив
};

foo.value.map(() => {});  //  Property 'map' does not exist on type 'string | string[]'

То что примерно мне нужно, я могу получить сделав функцию-обёртку:

function SomeType<T extends Some>(value: T): T {
  return value
}

const bar = SomeType({ 
  value: ['a', 'b'] // здесь всегда будет массив  
});

bar.value.map(() => {});  // ок

Но хотелось бы как-то правильно это делать.

...upd:
Что именно мне нужно:
a) при объявлении объекта он должен быть проверен на соответствие типу Some(чтоб ide мне сразу подсветила если я где-то ошибся и предложила автокомплит).
б) при последующей работе с объявленным объектом я не хочу уточнять в ручную каждый подтип каждого свойства и подсвойства возможного в типе Some, ts должен понять их из объявления.
с) объявленный объект должен всё ещё оставаться для ts вариантом типа Some, чтобы его можно было спокойно передавать в методы и функции ожидающие Some на вход.
д) объект должен оставаться мутабельным(в рамках конкретизированного типа, само собой).

Answer 1

[Aetae]

И вот в ts 4.9 наконец-то ввели фичу отвечающую на этот вопрос (буквально джва года ждал):

interface Some {
  value: string | string[];
}

const foo = {
  value: ['a', 'b'] // здесь всегда будет массив
} satisfies Some;

foo.value.map(() => {}); // ок

Answer 2

[Руслан Лопатин]

TypeScript так не умеет.

Могу предложить нормализацию сложных типов. Что-то типа такого:

// Заготовка для Some
interface SomeDraft {
  value?: string | string[]; // Массив или значение. Может отсутствовать.
}

// Some имеет более строгий тип и как можно меньшую вариативность,
// чтобы в коде не делать проверки.
interface Some {
  value: string[];  // Всегда присутствует. Всегда массив.
}

function makeSome({ value = [] }: SomeDraft): Some {
  // Приводим к нормальному (более строгому) типу
  return {
    value: Array.isArray(value) ? value : [value],
  };
}

// Здесь Some задаётся через заготовку - так проще задавать значения
// Но результат всегда более строгий - так проще значениями пользоваться
const foo = makeSome({ value: 'foo' }); // { value: ['foo'] }

foo.value.map(() => {}); // foo.value - всегда массив и TypeScript это знает

Comments

[Aetae]

Из коммента к другому ответу:

Объявить более узкий тип - очень больно: тут лишь пример, работа идёт со сложными структурами, с кучей вариантов и юнионов вложенных друг в друга.

Это тут задать узкий тип со string или со string[] - легко, а когда юнион типы вложены в юнион типы - это куча мартышкиной работы, по описанию того, что и так есть.

По поводу не умеет: через функцию обёртку же более-менее может. Конечно в таком варианте остаётся возможность напихать в объект лишнего, но всё что касается типа Some будет чётко типизировано.

[Руслан Лопатин]

Aetae По-моему "больно" работать именно с разлапистыми структурами, в которых каждое поле может быть записано разными вариантами. Я же предлагаю эту вариативность использовать с умом. То есть _только_ для задания исходных значений. Но пользоваться этими значениями уже в нормализованном, более строгом виде. Это как раз излечит "боль".

[Руслан Лопатин]

Aetae Впрочем это, разумеется, зависит от того, что вы с этими данными делать собираетесь. Если хотите их просто задать, но не пользоваться - может их нормализация и мартышкин труд. Но если вам над этими данными потом манипуляции сложные выполнять (и писать тесты), то это может оказаться не такой уж и пустой затеей. И с типизацией это связано далеко не в первую очередь.

[Aetae]

Руслан Лопатин, куча всего работает с "разлапистыми" структурами: формы, чарты, graphql тот же... И как-то удобной альтернативы им нет.

[Руслан Лопатин]

Aetae Разумеется есть:) Называется правильная архитектура. "Правильная" - это которая без излишней сложности. Например можно ведь не работать с объектными литералами, а сделать объектную модель, соответствующую предметной области. Которая ещё и ресурсы вычислительные экономит при этом. Впрочем во фронтэнде так не принято :)

[Aetae]

Руслан Лопатин, очень абстрактное заявление. Можно пример какой-нить либы, с такой прекрасной моделью?

Answer 3

[Станислав Макаров]

Вы какую-то странную задачу поставили. Если вам нужен более узкий тип - объявите его отдельно (и может быть даже объявите Some через этот более узкий тип) и пользуйтесь им, или даже вообще не указывайте тип в вашем примере.

UPD

объявленный объект должен всё ещё оставаться для ts вариантом типа Some, чтобы его можно было спокойно передавать в методы и функции ожидающие Some на вход.

Нижеследующий код более чем корректный:

interface Some {
  value: string | string[];
}

const foo = {
  value: ['a', 'b'] // здесь всегда будет массив
};

foo.value.map(() => { });

function f(a: Some) {
    return a;
}

f(foo);

при объявлении объекта он должен быть проверен на соответствие типу Some(чтоб ide мне сразу подсветила если я где-то ошибся и предложила автокомплит).

Значит всё-таки вам нужен не тип Some в месте объявления объекта, а более узкий тип, где value - всегда массив. Например:

interface Some {
  value: string | string[];
}

// Тут вам стоит придумать более подходящее по смыслу название
interface WithArrayValue {
    value: string[];
}

const foo: Some & WithArrayValue = {
    value: ['a', 'b'] // здесь всегда будет массив
};

foo.value.map(() => { });

function f(a: Some) {
    return a;
}

f(foo);

Comments

[Aetae]

Объявить более узкий тип - очень больно: тут лишь пример, работа идёт со сложными структурами, с кучей вариантов и юнионов вложенных друг в друга.
Не объявлять тип - не вариант, на кой мне тогда ts?

Что мне нужно:
a) при объявлении объекта он должен быть проверен на соответствие типу Some(чтоб ide мне сразу подсветила если я где-то ошибся и предложила автокомплит).
б) при последующей работе с объявленным объектом я не хочу уточнять в ручную каждый подтип каждого свойства и подсвойства возможного в типе Some, ts должен понять их из объявления.
с) объявленный объект должен всё ещё оставаться для ts вариантом типа Some, чтобы его можно было спокойно передавать в методы и функции ожидающие Some на вход.

По моему это логичные желания. (хотя я и понимаю, что они возникли из-за того, что ts и так излишне умный, писал бы я на Java - мне б и в голову такое не пришло:))

[Aetae]

По обновлению, ещё раз:

Объявить более узкий тип - очень больно: тут лишь пример, работа идёт со сложными структурами, с кучей вариантов и юнионов вложенных друг в друга.

Это тут задать узкий тип со string или со string[] - легко, а когда юнион типы вложены в юнион типы - это куча мартышкиной работы, по описанию того, что и так есть.

Проверка должна быть на соответствие типу Some, но уже вся последующая работа - с "суженным" типом. Т.е. я хочу в константу положить любую структуру соответствующую Some, и как-то после этого дать понять ts что структура не будет меняться, чтобы ts вы вел более узкий тип сам, а не я писал полотнища вручную. Чтобы вся последующая работа велась конкретно с этой структурой, а не "любым возможным Some".

Answer 4

[Interface]

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

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

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

interface Some {
    value: string | string[];
}

type Extends<E, T extends E> = T;

const foo = {
    value: ['a', 'b'] // здесь всегда будет массив
}
foo as Extends<Some, typeof foo>;

playground

То есть объявление переменной состоит из 2 выражений: объявление переменной с автоматическим выводом типа и валидация полученного типа.

P.s. к сожалению, просто foo as Some не отловит все, что нужно, например {value: ['a', 'b', 8]}

Comments

[Aetae]

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

[Interface]

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

Касательно решения, я бы на вашем месте использовал бы функцию, как вы описали. Не думаю, что некрасивость решения или оверхед перевешивают удобство в данном случае. Насколько я понимаю, TS сейчас не поддерживает никакого способа объявить переменную как вы хотите. Разве что вместо создания конкретной функции SomeType, я бы сделал функцию принимающую расширяемый type дженериком: https://www.typescriptlang.org/play/#code/JYOwLgpg...

[Aetae]

Interface, да с дженериком самоочевидно - только это ещё более некрасиво.)