Factory Function Types in TypeScript

Factory functions are a powerful design pattern that allows you to create objects with varying configurations without exposing the instantiation logic directly. This challenge focuses on defining TypeScript types that accurately represent factory functions, ensuring type safety and improved code maintainability. You'll be defining types for factory functions that produce objects with specific shapes and potentially accept configuration parameters.

Problem Description

The goal is to create TypeScript types that define the structure of factory functions. A factory function is a function that returns an object of a specific type. Your task is to define types for factory functions that:

1. Accept Configuration: The factory function may accept a configuration object as an argument. This configuration object will have properties that influence the creation of the returned object.
2. Return a Specific Object Type: The factory function must return an object conforming to a defined type.
3. Type Safety: The types should ensure that the configuration object's properties are correctly mapped to the properties of the returned object, and that the returned object adheres to the expected structure.

You will be provided with a target object type and a configuration type. Your task is to define a type for the factory function that takes the configuration type as input and returns the target object type.

Examples

Example 1:

// Target Object Type
interface Person {
  name: string;
  age: number;
}

// Configuration Type
interface PersonConfig {
  name: string;
  age?: number; // Age is optional
}

// Define the Factory Function Type
type PersonFactory = (config: PersonConfig) => Person;

Explanation: PersonFactory is a type that represents a function. This function accepts a PersonConfig object as input and returns a Person object. The ? in age?: number indicates that the age property in the configuration is optional.

Example 2:

// Target Object Type
interface Product {
  id: string;
  name: string;
  price: number;
  isAvailable: boolean;
}

// Configuration Type
interface ProductConfig {
  id: string;
  name: string;
  price: number;
}

// Define the Factory Function Type
type ProductFactory = (config: ProductConfig) => Product;

Explanation: ProductFactory represents a function that takes a ProductConfig object and returns a Product object. All properties in the configuration are required in this case.

Example 3: (Edge Case - No Configuration)

// Target Object Type
interface Point {
  x: number;
  y: number;
}

// Configuration Type (Empty)
interface PointConfig {}

// Define the Factory Function Type
type PointFactory = (config: PointConfig) => Point;

Explanation: PointFactory represents a function that takes an empty PointConfig object (meaning no configuration parameters) and returns a Point object. The factory function would need to provide default values for x and y internally.

Constraints

• The factory function type must accurately reflect the relationship between the configuration type and the object type it produces.
• The configuration type can contain optional properties.
• The factory function type must be generic enough to handle various configuration and object types.
• The solution should be concise and readable.

Notes

• Consider how to handle optional properties in the configuration type.
• Think about how to represent a factory function that takes no configuration at all.
• Focus on defining the type of the factory function, not implementing the factory function itself. You are only defining the shape of the function.
• The configuration object's properties should map to the object's properties, but the mapping doesn't need to be one-to-one. The factory function can perform transformations or calculations based on the configuration.