Swap keys

[goodmind]

Do you know how to write type like this one?

type Swap<T> = ...

type A = { a: 'b', c: 'd' }
type B = Swap<A> // { b: 'a', d: 'c' }

[KiaraGrouwstra]

Tried for a bit, here's what I came up with:

export type Obj<T> = { [k: string]: T };
export type UnionHasKey<Union extends string, K extends string> = ({[S in Union]: '1' } & Obj<'0'>)[K];
export type If<Cond extends '0'|'1', Then, Else> = { 1: Then, 0: Else }[Cond];

type A = { a: 'b', c: 'd' };

type Keys = keyof A; // "a" | "c"
type Vals = A[keyof A]; // "b" | "d"
type y = {[P1 in Vals]: {[P2 in keyof A]: If<UnionHasKey<A[P2], P1>, P2, never> }[Keys] }; // { b: "a"; d: "c"; }

type Swap<
    T extends { [k: string]: string },
    Keys extends keyof T = keyof T,
    Vals extends string = T[Keys]
> = {[P1 in Vals]: {[P2 in Keys]: If<UnionHasKey<T[P2], P1>, P2, never> }[Keys]};

type B = Swap<A>;

Still fails in playground, though I think master should have fixed most issues like this. Haven't managed to test that way yet, but yeah.

[goodmind]

@tycho01 wow, still trying to figure out how things in this repo ever works

[KiaraGrouwstra]

Haha :), I just try step by step too, but yeah, it looks more complex when put together. To sorta illustrate what's going on:

• UnionHasKey<A[P2], P1> is just a fancy type version of an equality check (P1 == A[P2]).
• the outer loop is making an object based on the values as keys
• to return the inner key we need to grab it from the object
• the only way to extract just that from the object is to get the values in a filtered way
• you get the values by doing another mapped object
• you filter by selectively keeping either the values or never
• when reduced into a union ('b' | never), all the nevers automatically get scrubbed out
• done! :)

[SimonMeskens]

Nice one! :)

I kinda gave up after

type strT = {
    [key: string]: string
}

type Swap<T extends strT> = {
    [N in T[keyof T]]: ???
}

type A = { a: 'b', c: 'd' }
type B = Swap<A>