Add new type: ValuesType

[piotrwitek]

Proposal to add ValuesType, looking for feedback:

export type ValuesType<T extends ArrayLike[] | Record<string, any>> = T extends ArrayLike[]
  ? T[number]
  : T extends object
  ? T[keyof T]
  : never;

const arr = [1, 2];
const obj = { key: 'value' };

type t1 = typeof arr[number];
type t2 = typeof obj[keyof typeof obj]; // this is really mouthful and I was annoyed by this many times

// consistent and simple
type t3 = ValuesType<typeof arr>; // number
type t4 = ValuesType<typeof obj>; // string

---

IssueHunt Summary

axure has been rewarded.

Backers (Total: $25.00)

• issuehunt ($25.00)

Submitted pull Requests

• #99 Add new type: ValuesType

---

Tips

• Checkout the Issuehunt explorer to discover more funded issues.
• Need some help from other developers? Add your repositories on IssueHunt to raise funds.

---

IssueHunt has been backed by the following sponsors. Become a sponsor

[levenleven]

I think { [K in keyof T]: T[K] extends any ? T[K] : never }[keyof T] part can be simplified to T[keyof T]

[piotrwitek]

@levenleven agreed! I corrected the proposal, thanks!

[levenleven]

Another suggestion regarding constraints. I find them a bit restrictive

1. any [] - maybe it is enough to just require ArrayLike<any> so readonly arrays will also work
2. Record<string, any> - maybe just object? Is it needed at all?

[piotrwitek]

@levenleven As far as I tested any[] works with readonly arrays
Record<string, any> is much better than object, but optimal would be Record<any, any> - it allows for better constrains in conditional types, so I use them as default

[IssueHuntBot]

@IssueHunt has funded $25.00 to this issue.

---

• Submit pull request via IssueHunt to receive this reward.
• Want to contribute? Chip in to this issue via IssueHunt.
• Checkout the IssueHunt Issue Explorer to see more funded issues.
• Need help from developers? Add your repository on IssueHunt to raise funds.

[levenleven]

Here's an example where it doesn't work with readonly arrays:

const arr = [1, 2] as const;

See result of ValuesType<typeof arr>
Playground

[piotrwitek]

Thanks for the example now I understand 👍 So the problem here is it's a tuple, not a read-only array, which needs a special case treatment a length property which ArrayLike implements.

Yeah, I agree we should go with ArrayLike condition.

[issuehunt-oss]

@piotrwitek has rewarded $17.50 to @Axure. See it on IssueHunt

• 💰 Total deposit: $25.00
• 🎉 Repository reward(20%): $5.00
• 🔧 Service fee(10%): $2.50

[drewlustro]

I could be misunderstanding this utility type, but it doesn't look like it works for interfaces:

interface Foo {
  bar: string;
  baz: number;
}

type FooValue = ValuesType<Foo>;
// expected: string | number
// received: any

[piotrwitek]

@drewlustro actually I have tested and it works.