TypeScript Constructor Type Utilities

This challenge focuses on creating advanced type utilities in TypeScript that allow you to manipulate and infer types related to class constructors. Understanding these utilities is crucial for building robust and flexible type-safe libraries and frameworks that interact with classes.

Problem Description

Your task is to implement two TypeScript utility types:

1. ConstructorParameters<T>: This utility type should extract the types of the parameters from a constructor signature of a given class type T.
2. InstanceType<T>: This utility type should extract the type of the instance that a given constructor type T creates.

Key Requirements:

• ConstructorParameters<T>:
  • Must correctly infer the parameter types for a class constructor.
  • Should handle constructors with zero, one, or multiple parameters.
  • Should return a tuple of the parameter types.
• InstanceType<T>:
  • Must correctly infer the type of the object created by new T(...).
  • Should work with any valid constructor type.

Expected Behavior:

Given a class type, ConstructorParameters should produce a tuple representing the arguments needed to instantiate that class, and InstanceType should produce the type of the object that the class creates.

Edge Cases to Consider:

• Classes with no constructor (implicitly has a default constructor with no arguments).
• Classes with constructors that take optional parameters or rest parameters (though for simplicity, focus on required parameters first, and consider optional/rest if time permits).

Examples

Example 1:

class MyClass {
  constructor(name: string, age: number) {
    // ...
  }
}

type MyClassConstructorParams = ConstructorParameters<typeof MyClass>;
// Expected: [name: string, age: number]

Example 2:

class EmptyClass {}

type EmptyClassConstructorParams = ConstructorParameters<typeof EmptyClass>;
// Expected: []

Example 3:

class Greeter {
  greeting: string;
  constructor(message: string = "Hello") {
    this.greeting = message;
  }
}

type GreeterInstance = InstanceType<typeof Greeter>;
// Expected: Greeter

type GreeterConstructorParams = ConstructorParameters<typeof Greeter>;
// Expected: [message?: string | undefined] (Note: handling optional/default is advanced)
// For the primary challenge, focus on required parameters first.

Constraints

• The solution must be implemented in TypeScript.
• You should not use the built-in ConstructorParameters and InstanceType utility types provided by TypeScript's standard library (lib.d.ts). You need to re-implement their functionality.
• The solution should be purely at the type level, using type manipulations and conditional types.
• Focus on correctly handling standard class constructors with required parameters. Advanced handling of optional, default, or rest parameters can be considered a bonus.

Notes

This challenge requires a good understanding of TypeScript's advanced type features, including:

• Indexed Access Types: Accessing properties of an object type.
• Conditional Types: Creating types that depend on other types.
• infer Keyword: Inferring types within conditional types.
• Constructor Signatures: How to represent and work with the type of a constructor.

To infer constructor parameters, you'll likely need to leverage the fact that a class type can be "called" like a constructor. Think about how you can access the signature of such a call. For InstanceType, consider what you get when you instantiate a class.