Как в typescript объединить ключи, и если появляются повторы, то сделать объединение типов?

Question

[Алексей Шашенков]

Нужно из R преобразовать в Result дженериком. Будет идеально, если решение будет поддерживать глубину более 4.

type A = {
  i: boolean;
  o: void;
};

type B = {
  i: string;
  o: number;
};

type R = {
  A: A;
  B: B;
};

Получить тип

type Result = {
  'A.i': boolean;
  'A.o': void;
  'B.i': string;
  'B.o': number;
  // ключи выше я могу получить, но звездочки не погу решить. 
  '*.i': string | boolean;
  '*.o': void | number;
  'A.*': boolean | void;
  'B.*': string | number;
  '*.*': boolean | void | number | string;
}

Comments

[Alexandroppolus]

Прикольный тайп-челлендж)

Глубина объекта R одинакова?

[Алексей Шашенков]

Alexandroppolus, Да, но сейчас там она 4.

Вот пример ключей
player.transactions.addItems.1

[WbICHA]

Алексей Шашенков, имена свойств у всех одинаковые? Глубина везде одинаковая? Путь должен быть всегда полный ('a.b.c.d': any или может быть 'a.b': { c: { d: any } }?

[Алексей Шашенков]

WbICHA, Всегда полный. Это делается для очереди. Чтобы типизировать ответ

[WbICHA]

Алексей Шашенков, а что по остальным вопросам?)

[Алексей Шашенков]

WbICHA,
Имена свойств у всех одинаковые? - разные.
Глубина везде одинаковая? - да, контракт.
Путь должен быть всегда полный? - да. 'a.b.c.d'

[WbICHA]

Алексей Шашенков, Alexandroppolus, пока так (с глубиной 2), позже нормально сделаю.

https://www.typescriptlang.org/play/?#code/C4TwDgp...

[szQocks]

WbICHA, как у тебя там с этим ts ещё крыша не поехала, сколько проектов видел, везде одно и тоже - каша из типов, куча вложенностей с наследованием

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

[Alexandroppolus]

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

[Alexandroppolus]

WbICHA, судя по примеру "player.transactions.addItems.1", там ещё кортежи могут быть

[WbICHA]

szQocks, хех, хз, никогда не испытывал с этим проблем.) Хотя соглашусь, из-за ограничений тса код в ряде случаев получается очень не очень с точки зрения читабельности.

Но, на самом деле, как и сказал Alexandroppolus, сложные типы в проекте в целом редкость. У меня такие только для типизации путей и для антд формы (она по умолчанию так себе типизирована).

Answer 1

[Alexandroppolus]

Запилил такой вариант.

Поддерживаются вложенные объекты и массивы (кортежи), см. пример. Глубина рекурсии произвольная, но результат получается здоровенный, если много всего.

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

Comments

[WbICHA]

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

[WbICHA]

Впрочем, я всё равно к этому плану в итоге вернулся. :D

[Alexandroppolus]

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

Answer 2

[WbICHA]

Решение за один проход с поддержкой массивов и таплов. Глубина любая.

https://www.typescriptlang.org/play/?#code/C4TwDgp...

Основное отличие от решения Alexandroppolus, ключи собираются последовательно и не парсятся, но результат, понятное дело, одинаковый.

type JoinKeys<T extends object> = JoinKeysDeep<T> extends infer J extends Record<
  string,
  unknown
>
  ? { [Key in J extends J ? keyof J : never]: J extends J ? J[Key] : never }
  : never;

type JoinKeysDeep<
  T extends object,
  K extends keyof T = JoinKeysDeep.GetKeys<T> & keyof T,
> = K extends K & (string | number)
  ? T[K] extends object
    ? JoinKeysDeep<T[K]> extends infer J extends Record<string, unknown>
      ? J extends J
        ? Record<`${K | '*'}.${keyof J & (string | number)}`, J[keyof J]>
        : never
      : never
    : Record<K | '*', T[K]>
  : never;
namespace JoinKeysDeep {
  export type GetKeys<T> = T extends unknown[]
    ? keyof T &
        (number extends T['length']
          ? // array
            number
          : // tuple
            `${number}`)
    : keyof T;
}

Comments

[WbICHA]

Кстати, szQocks, зацени, ну прелесть же, а не код. :3

[szQocks]

WbICHA, к сожалению не могу оценить, из-за недостатка знаний ts, могу лишь перекреститься от увиденного)

я пытался учить ts, и php но никак, никак душа не лежит к ним

[WbICHA]

szQocks, это норма.) Вообще, тс сильно на логические языки похож, а это другая парадигма, так что вполне логично, что он не так прост в понимании. А уж глубокие знания так тем более.

[Alexandroppolus]

ага, понял вроде бы.. На каждый лист дерева здесь свой рекорд, со всеми 2^depth составными ключами, по которым к листу можно прийти. И потом в JoinKeys объединение рекордов.

да, прикольно.

[Alexandroppolus]

WbICHA,

Вообще, тс сильно на логические языки похож, а это другая парадигма

ещё разница в том, что он работает с множествами, а в "обычном" коде мы оперируем одиночными сущностями.

[WbICHA]

Alexandroppolus, ага. По сути, мы просто получаем юнион объектов, у которых по несколько ключа: свой уникальный полный путь и все варианты со звёздочкой. И у всех у них один тип. А после, благодаря тому, что ключи со звёздочкой есть и в других объектах, при доставании мы получаем юнион всех типов из всех объектов, у которых есть такой ключ.

ещё разница в том, что он работает с множествами, а в "обычном" коде мы оперируем одиночными сущностями.

Скорее тут основная загвоздка, что мы неявно работаем с множествами. Всё же подобное выглядит довольно странно.)

{ [Key in J extends J ? keyof J : never]: J extends J ? J[Key] : never } // JJJJJJJJJJJJJJJJ

[modelair]

плюсую :)