Constructor Type Utilities in TypeScript

Constructor type utilities are powerful tools in TypeScript that allow you to derive the type of an object based on its constructor function. This is incredibly useful for working with classes, factories, and other scenarios where you need to understand the type of an object created by a specific constructor. This challenge will guide you in creating these utilities.

Problem Description

The goal is to create two TypeScript utility types: ConstructSignature and ConstructorType. ConstructSignature should extract the signature of a constructor function. ConstructorType should infer the return type of a constructor function, effectively representing the type of object it creates.

Key Requirements:

• ConstructSignature<T>: This utility type should take a constructor function T as input and return its signature as a function type. The signature should include the parameter types and the return type (which should be T).
• ConstructorType<T>: This utility type should take a constructor function T as input and return the type that the constructor creates (i.e., the return type of the constructor).

Expected Behavior:

• The utilities should work correctly with both class constructors and function constructors.
• The utilities should handle constructors with and without parameters.
• The utilities should correctly infer the return type even when the constructor is complex.

Edge Cases to Consider:

• Constructors with optional parameters.
• Constructors with rest parameters.
• Constructors that return void or never.
• Constructors that return primitive types (string, number, boolean).
• Constructors that return union types.

Examples

Example 1:

class Person {
  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }
  name: string;
  age: number;
}

type ExpectedSignature = (name: string, age: number) => Person;
type ExpectedType = Person;

// Assertions (not part of the solution, just for demonstration)
type SignatureCheck = ConstructSignature<typeof Person>;
type TypeCheck = ConstructorType<typeof Person>;

// Should match ExpectedSignature and ExpectedType

Example 2:

function createPoint(x: number, y: number): { x: number; y: number } {
  return { x, y };
}

type ExpectedSignature2 = (x: number, y: number) => { x: number; y: number };
type ExpectedType2 = { x: number; y: number };

// Assertions (not part of the solution)
type SignatureCheck2 = ConstructSignature<typeof createPoint>;
type TypeCheck2 = ConstructorType<typeof createPoint>;

// Should match ExpectedSignature2 and ExpectedType2

Example 3:

class Empty {
  constructor() {}
}

type ExpectedSignature3 = () => Empty;
type ExpectedType3 = Empty;

// Assertions (not part of the solution)
type SignatureCheck3 = ConstructSignature<typeof Empty>;
type TypeCheck3 = ConstructorType<typeof Empty>;

// Should match ExpectedSignature3 and ExpectedType3

Constraints

• The solution must be written in TypeScript.
• The solution must be type-safe and avoid any type assertions where possible.
• The solution should be as generic as possible to handle a wide range of constructor functions.
• Performance is not a primary concern for this challenge, but avoid unnecessarily complex or inefficient solutions.

Notes

• Consider using conditional types and mapped types to achieve the desired results.
• The InstanceType<T> utility type can be helpful, but you should aim to implement the logic from scratch to understand the underlying principles.
• Think about how to handle the return type of the constructor function accurately. The return type is not always directly accessible, so you may need to use inference techniques.
• Focus on creating reusable and well-typed utility types.