Can TypeScript accurately perform the _.invert function?

Question

Can TypeScript accurately perform the _.invert function?

When using lodash, you can utilize the _.invert function to switch an object's keys and values:

var object = { 'a': 'x', 'b': 'y', 'c': 'z' };

_.invert(object);
// => { 'x': 'a', 'y': 'b', 'z': 'c' }

The current definitions in the lodash typings always specify a string→string mapping for this function:

_.invert(object);  // type is _.Dictionary<string>

However, in certain cases, particularly when utilizing a const assertion, a more accurate type might be necessary:

const o = {
  a: 'x',
  b: 'y',
} as const;  // type is { readonly a: "x"; readonly b: "y"; }
_.invert(o);  // type is _.Dictionary<string>
              // but it would ideally be { readonly x: "a", readonly y: "b" }

Is there a way to achieve typings that precise? The following declaration comes close:

declare function invert<
  K extends string | number | symbol,
  V extends string | number | symbol,
>(obj: Record<K, V>): {[k in V]: K};

invert(o);  // type is { x: "a" | "b"; y: "a" | "b"; }

While the keys are correct, the values result in a union of input keys, meaning the specificity of the mapping is lost. Is it possible to achieve perfect precision in this scenario?

typescript lodash typescript-generics typescript-declarations

Answer 1

Answer №1

Revise

With the implementation of the as clause in mapped types, you have the ability to define this type as follows:

You can utilize a mapped type with an as clause:



type InvertResult<T extends Record<PropertyKey, PropertyKey>> = {
  [P in keyof T as T[P]]: P
}

Playground Link

Initial response

You can achieve this using a more complex mapped type that maintains the accurate value:

const o = {
    a: 'x',
    b: 'y',
} as const;

type AllValues<T extends Record<PropertyKey, PropertyKey>> = {
    [P in keyof T]: { key: P, value: T[P] }
}[keyof T]
type InvertResult<T extends Record<PropertyKey, PropertyKey>> = {
    [P in AllValues<T>['value']]: Extract<AllValues<T>, { value: P }>['key']
}
declare function invert<
    T extends Record<PropertyKey, PropertyKey>
>(obj: T): InvertResult<T>;

let s = invert(o);  // type is { x: "a"; y: "b"; }

Playground Link

AllValues initially creates a union containing all key, value pairs (for example:

{ key: "a"; value: "x"; } | { key: "b"; value: "y"; }

). In the mapped type, we iterate over all value types in the union and extract the original key for each value using Extract. This method works effectively unless there are duplicate values, in which case it results in a union of keys where the value appears.

Answer 2

Revise

With the implementation of the as clause in mapped types, you have the ability to define this type as follows:

You can utilize a mapped type with an as clause:



type InvertResult<T extends Record<PropertyKey, PropertyKey>> = {
  [P in keyof T as T[P]]: P
}

Playground Link

Initial response

You can achieve this using a more complex mapped type that maintains the accurate value:

const o = {
    a: 'x',
    b: 'y',
} as const;

type AllValues<T extends Record<PropertyKey, PropertyKey>> = {
    [P in keyof T]: { key: P, value: T[P] }
}[keyof T]
type InvertResult<T extends Record<PropertyKey, PropertyKey>> = {
    [P in AllValues<T>['value']]: Extract<AllValues<T>, { value: P }>['key']
}
declare function invert<
    T extends Record<PropertyKey, PropertyKey>
>(obj: T): InvertResult<T>;

let s = invert(o);  // type is { x: "a"; y: "b"; }

Playground Link

AllValues initially creates a union containing all key, value pairs (for example:

{ key: "a"; value: "x"; } | { key: "b"; value: "y"; }

). In the mapped type, we iterate over all value types in the union and extract the original key for each value using Extract. This method works effectively unless there are duplicate values, in which case it results in a union of keys where the value appears.

Answer 3

Answer №2

Titian Cernicova-Dragomir's approach is quite impressive. I recently discovered another method to interchange object keys and values using Conditional Types:

type KeyFromValue<V, T extends Record<PropertyKey, PropertyKey>> = {
  [K in keyof T]: V extends T[K] ? K : never
}[keyof T];

type Invert<T extends Record<PropertyKey, PropertyKey>> = {
  [V in T[keyof T]]: KeyFromValue<V, T>
};

Try it out with the object const o:

const o = {
  a: "x",
  b: "y"
} as const;

// type Invert_o = {x: "a"; y: "b";}
type Invert_o = Invert<typeof o>;

// works
const t: Invert<typeof o> = { x: "a", y: "b" };
// Error: Type '"a1"' is not assignable to type '"a"'.
const t1: Invert<typeof o> = { x: "a1", y: "b" };

Define the function invert following the same pattern as the above solution with a Return type of Invert<T>.

Playground

Answer 4

Titian Cernicova-Dragomir's approach is quite impressive. I recently discovered another method to interchange object keys and values using Conditional Types:

type KeyFromValue<V, T extends Record<PropertyKey, PropertyKey>> = {
  [K in keyof T]: V extends T[K] ? K : never
}[keyof T];

type Invert<T extends Record<PropertyKey, PropertyKey>> = {
  [V in T[keyof T]]: KeyFromValue<V, T>
};

Try it out with the object const o:

const o = {
  a: "x",
  b: "y"
} as const;

// type Invert_o = {x: "a"; y: "b";}
type Invert_o = Invert<typeof o>;

// works
const t: Invert<typeof o> = { x: "a", y: "b" };
// Error: Type '"a1"' is not assignable to type '"a"'.
const t1: Invert<typeof o> = { x: "a1", y: "b" };

Define the function invert following the same pattern as the above solution with a Return type of Invert<T>.

Playground

Answer 5

Answer №3

Implementing this feature is made much easier thanks to the introduction of Key Remapping in Mapped Types in TypeScript 4.1:

const data = {
    name: 'John',
    age: 30
} as const;

declare function reverse<
    T extends Record<PropertyKey, PropertyKey>
>(input: T): {
    [K in keyof T as T[K]]: K
};

let output = reverse(data);  // resulting type will be { readonly John: "name"; readonly 30: "age"; }

playground

Answer 6

Implementing this feature is made much easier thanks to the introduction of Key Remapping in Mapped Types in TypeScript 4.1:

const data = {
    name: 'John',
    age: 30
} as const;

declare function reverse<
    T extends Record<PropertyKey, PropertyKey>
>(input: T): {
    [K in keyof T as T[K]]: K
};

let output = reverse(data);  // resulting type will be { readonly John: "name"; readonly 30: "age"; }

playground

Can TypeScript accurately perform the _.invert function?

Answer №1

Answer №2

Answer №3

Similar questions

Errors can occur when using TypeScript recursive types

After verifying the variable is an Array type, it is ideal to utilize the .forEach()

Troubleshooting Axios errors when using createAsyncThunk function

Having trouble getting Lodash find to work properly with TypeScript overload signatures

Unreliable TypeScript errors when using spread arguments

Tips for integrating Typescript Definition files with Visual Studio 2017

Encountering a navCtrl problem in Ionic 3 while attempting to utilize it within a service

Cannot execute loop

What is the process for setting the values of an object within a constructor to all class properties?

When utilizing DomSanitizer, Angular2 suddenly ceases to function properly

Display captions on react-player videos using an .srt file

Triggering actionsheet button clicks in Ionic 3

Display <video> component using Angular 2

Electron does not have the capability to utilize Google's Speech to Text engine

Guide on accessing a modal component in Angular?

The toISOString() method is deducting a day from the specified value

Develop a custom function in Typescript that resolves and returns the values from multiple other functions

How come the value passed to the component props by getServerSideProps is incorrect?

Does the class effectively implement the interface even if the method of a member variable has undefined arguments?

Create an abstract method that will return the properties of the constructor