Mastering TypeScript's keyof Operator: Advanced Utility Types

TypeScript's keyof operator is a powerful tool for extracting the union of property names from an object type. However, building custom utility types that leverage keyof in more sophisticated ways can unlock cleaner, more robust, and maintainable code. This challenge will test your understanding of keyof and your ability to combine it with other TypeScript features to create reusable type utilities.

Problem Description

Your task is to create two advanced TypeScript utility types:

1. ObjectKeys<T>: This utility type should take a generic type T and return a union of all string literal keys of T. This is functionally similar to the built-in keyof T, but we'll be implementing it from scratch for practice.
2. ObjectValues<T>: This utility type should take a generic type T and return a union of all the value types of T. For example, if T has properties of type string and number, ObjectValues<T> should return string | number.

You will need to ensure your utility types are correctly defined and can be applied to various object types.

Key Requirements

• Implement ObjectKeys<T> using TypeScript's type-level programming.
• Implement ObjectValues<T> using TypeScript's type-level programming.
• Both types should be generic over a single type parameter T.
• The type T should be constrained to be an object type (or something that can be treated as such for key extraction, like an array type or function type).

Expected Behavior

• ObjectKeys<T> should produce a union of string literal types representing the keys of T.
• ObjectValues<T> should produce a union of the types of the values associated with the keys of T.

Edge Cases

• Consider an empty object type.
• Consider types with optional properties.
• Consider types with index signatures.

Examples

Example 1: ObjectKeys

interface User {
  id: number;
  name: string;
  isActive?: boolean;
}

// Expected output: "id" | "name" | "isActive"
type UserKeys = ObjectKeys<User>;

Explanation: ObjectKeys<User> inspects the User interface and extracts all its public property names, forming a union of string literals.

Example 2: ObjectValues

interface Product {
  id: string;
  price: number;
  tags: string[];
}

// Expected output: string | number | string[]
type ProductValues = ObjectValues<Product>;

Explanation: ObjectValues<Product> inspects the Product interface and extracts the types of all its properties, forming a union of these types.

Example 3: Index Signatures and Optional Properties

interface Settings {
  [key: string]: string | number | undefined;
  timeout: number;
  theme: "dark" | "light";
}

// Expected output for ObjectKeys<Settings>: string | "timeout" | "theme"
type SettingsKeys = ObjectKeys<Settings>;

// Expected output for ObjectValues<Settings>: string | number | undefined | "dark" | "light"
type SettingsValues = ObjectValues<Settings>;

Explanation: For ObjectKeys, it includes the index signature key (string) as well as named properties. For ObjectValues, it includes the union of types from named properties and the index signature type. Note that the explicit types for timeout and theme are more specific and should be included in the union if they are not already covered by the index signature.

Constraints

• You must use TypeScript's built-in type manipulation features, including generic constraints, mapped types, and conditional types if necessary.
• Avoid using runtime JavaScript code. This is a purely type-level challenge.
• The solution should be efficient and compile quickly.

Notes

• Remember that keyof T inherently produces a union of string literal types. Your ObjectKeys implementation should aim to replicate this behavior.
• For ObjectValues, you can think about how to access the type of a property given its key.
• Consider the type T[keyof T] – what does this represent, and how might it be useful for ObjectValues?
• The constraint T extends object or a similar form might be helpful to ensure T is an object-like type.