The type of Object.values() is not determined by a union or Records

Question

The type of Object.values() is not determined by a union or Records

When utilizing TypeScript, the Object.values() function encounters issues in deducing the accurate type from a union of Records:

type A = Record<string, number>;
type B = Record<string, boolean>;

function func(value: A | B) {
    const properties = Object.values(value); // any[]
}

TS Playground

I anticipate properties to be either number[] or boolean[], yet it is indeed any[].

Is there a method to properly determine the type from Object.values()?

typescript

Answer 1

Answer №1

When the Object.values(v) function is called, the compiler attempts to match the variable v against a type of {[k: string]: T} for a generic argument T that it automatically infers (as per this call signature).

If v has a type like {[k: string]: Z}, then the compiler will infer T as

Z</code, leading to successful compilation. However, if <code>v

is a union of records such as

{[k: string]: X} | {[k: string]: Y}

, the inference process differs. The algorithm does not directly synthesize X | Y as the inferred type

T</code. Instead, it selects one candidate - let's say, <code>X

- and raises an error if

Record<string, X> | Record<string, Y>

cannot be assigned to Record<string, X>.

This intentional avoidance of synthesizing union types aims to prevent situations where every call would succeed, causing potential issues with mismatched types.

In your scenario, however, you desire this union inference. An open feature request at microsoft/TypeScript#44312 proposes a method to facilitate this inference, although it is not yet incorporated into the language.

Hence, relying on the compiler to directly infer the desired union type is not feasible.

Instead, we can explicitly specify the union type when calling Object.values(), like so: Object.values<X | Y>(v). This means in your case, you could use

Object.values<number | boolean>(value)

and achieve the desired outcome.

However, hardcoding the type argument may not be ideal as you want it to dynamically adapt based on the type of value. To compute the type X | Y from a value such as

{[k: string]: X} | {[k: string]: Y}

, we can utilize the typeof type query operator paired with indexed access types.

For example:

Object.values<typeof value[string]>(value); // okay

To summarize using a general example:

function foo() {
    type A = Record<string, X>;
    type B = Record;
    function func(value: A | B) {
        return Object.values(value);        
    }
    // func(value: Record<string, X> | Record<string, Y>): (X | Y)[]
}

Within foo(), the func() function accepts a value of type A | B and returns a value typed as (X | Y)[], without requiring manual specification of X | Y. By employing typeof value[string], the compiler effectively calculates and utilizes the appropriate inferred union type.

Playground link to code

Answer 2

When the Object.values(v) function is called, the compiler attempts to match the variable v against a type of {[k: string]: T} for a generic argument T that it automatically infers (as per this call signature).

If v has a type like {[k: string]: Z}, then the compiler will infer T as

Z</code, leading to successful compilation. However, if <code>v

is a union of records such as

{[k: string]: X} | {[k: string]: Y}

, the inference process differs. The algorithm does not directly synthesize X | Y as the inferred type

T</code. Instead, it selects one candidate - let's say, <code>X

- and raises an error if

Record<string, X> | Record<string, Y>

cannot be assigned to Record<string, X>.

This intentional avoidance of synthesizing union types aims to prevent situations where every call would succeed, causing potential issues with mismatched types.

In your scenario, however, you desire this union inference. An open feature request at microsoft/TypeScript#44312 proposes a method to facilitate this inference, although it is not yet incorporated into the language.

Hence, relying on the compiler to directly infer the desired union type is not feasible.

Instead, we can explicitly specify the union type when calling Object.values(), like so: Object.values<X | Y>(v). This means in your case, you could use

Object.values<number | boolean>(value)

and achieve the desired outcome.

However, hardcoding the type argument may not be ideal as you want it to dynamically adapt based on the type of value. To compute the type X | Y from a value such as

{[k: string]: X} | {[k: string]: Y}

, we can utilize the typeof type query operator paired with indexed access types.

For example:

Object.values<typeof value[string]>(value); // okay

To summarize using a general example:

function foo() {
    type A = Record<string, X>;
    type B = Record;
    function func(value: A | B) {
        return Object.values(value);        
    }
    // func(value: Record<string, X> | Record<string, Y>): (X | Y)[]
}

Within foo(), the func() function accepts a value of type A | B and returns a value typed as (X | Y)[], without requiring manual specification of X | Y. By employing typeof value[string], the compiler effectively calculates and utilizes the appropriate inferred union type.

Playground link to code

Answer 3

Answer №2

Here is an example of how you can create the interface for a custom object construct called ObjectConstructorAlt.

declare interface ObjectConstructorAlt {
    values<T>(o: T):
    T extends any ?
        T extends Record<string|number, infer V> ? V[] 
            : T extends (infer V)[] ? V[]
            : any
        : never       
    ;
}
type A = Record<string, number>;
type B = Record<string, boolean>;
declare const a:A;
declare const b:B;
declare const ab:A|B;

Object.values(a); // number[]
Object.values(b); // boolean[]
Object.values(ab); // any[]

// actual implementation
const ObjectAlt: ObjectConstructorAlt = {
    values<T>(x: T){ 
        return Object.values(x as object) as any; 
    }
}
ObjectAlt.values(a); // number[]
ObjectAlt.values(b); // boolean[]
ObjectAlt.values(ab); // number[] | boolean[]

Typescript

If by some miraculous chance you were able to convince the TypeScript team to replace the current ObjectConstructor

interface ObjectConstructor {
    values<T>(o: { [s: string]: T } | ArrayLike<T>): T[];
    values(o: {}): any[];
    ...
}

with something like ObjectConstructorAlt, then you wouldn't need to apply a patch on your own. However, this scenario is highly unlikely as it could lead to longer compile times and potentially break other functionalities.

update - Just for your information, I raised this issue with TypeScript as an official concern and unfortunately, the existing behavior of Object.values/entries has been deemed not faulty. There are historical reasons behind this decision, which you can read about here.

Answer 4

Here is an example of how you can create the interface for a custom object construct called ObjectConstructorAlt.

declare interface ObjectConstructorAlt {
    values<T>(o: T):
    T extends any ?
        T extends Record<string|number, infer V> ? V[] 
            : T extends (infer V)[] ? V[]
            : any
        : never       
    ;
}
type A = Record<string, number>;
type B = Record<string, boolean>;
declare const a:A;
declare const b:B;
declare const ab:A|B;

Object.values(a); // number[]
Object.values(b); // boolean[]
Object.values(ab); // any[]

// actual implementation
const ObjectAlt: ObjectConstructorAlt = {
    values<T>(x: T){ 
        return Object.values(x as object) as any; 
    }
}
ObjectAlt.values(a); // number[]
ObjectAlt.values(b); // boolean[]
ObjectAlt.values(ab); // number[] | boolean[]

Typescript

If by some miraculous chance you were able to convince the TypeScript team to replace the current ObjectConstructor

interface ObjectConstructor {
    values<T>(o: { [s: string]: T } | ArrayLike<T>): T[];
    values(o: {}): any[];
    ...
}

with something like ObjectConstructorAlt, then you wouldn't need to apply a patch on your own. However, this scenario is highly unlikely as it could lead to longer compile times and potentially break other functionalities.

update - Just for your information, I raised this issue with TypeScript as an official concern and unfortunately, the existing behavior of Object.values/entries has been deemed not faulty. There are historical reasons behind this decision, which you can read about here.

The type of Object.values() is not determined by a union or Records

Answer №1

Answer №2

Similar questions

"Encountering a TypeScript error when using React Query's useInfiniteQuery

Tips for fixing the error message "unable to access property 'property-name' of null"

Is there a mistake in the TypeScript guide for custom typography in MUI5?

The string returned from the Controller is not recognized as a valid JSON object

Combining two sets of data into one powerful tool: ngx-charts for Angular 2

What is the reasoning behind defaultValue possessing the type of any in TextField Material UI?

How can I efficiently map an array based on multiple other arrays in JavaScript/TypeScript using ES6(7) without nested loops?

Mapping properties between objects in Typescript: transferring data from one object to another

Error encountered while loading a plugin in Typescript and RequireJS compilation process

Error: Uncaught TypeError - Unable to access 'reduce' property of undefined value

What could be causing this function to malfunction?

Various types of generics within an object

In the realm of JavaScript and TypeScript, the task at hand is to locate '*' , '**' and '`' within a string and substitute them with <strong></strong> and <code></code>

The element is implicitly assigned an 'any' type as the expression of type 'any' cannot be used to index a type with createStyles

Having trouble importing the d3-geo package into a Node.js TypeScript project

Angular data binding between an input element and a span element

What is the way to send custom properties to TypeScript in combination with StyledComponents?

Notify programmers about the potential risks associated with utilizing certain third-party components

Conceal the Angular Material toolbar (top navigation bar) automatically when scrolling downwards

Can TypeScript be used to generate a union type that includes all the literal values from an input string array?