TypeScript Factory Function Signatures

This challenge focuses on designing robust and flexible type signatures for factory functions in TypeScript. Factory functions are a common design pattern used to create objects. Precisely typing these functions can be tricky, especially when dealing with generic types and variations in the created objects.

Problem Description

Your task is to create a set of TypeScript type definitions that accurately represent a factory function. This factory function should be capable of creating different types of "products" based on specific configurations or options passed to it. You'll need to define types for the factory function itself, as well as for the products it might create. Consider scenarios where the factory function might return different types of objects or objects with slightly different structures.

Key Requirements:

1. Generic Factory Function Type: Define a generic type for the factory function. This type should accept type parameters that allow it to be specialized for different product types and configuration options.
2. Product Type Definition: Define a base type or interface for the products that the factory function will create.
3. Configuration/Options Type: Define a type for the configuration or options that will be passed to the factory function to influence the creation of the product.
4. Return Type: The factory function type should correctly infer and return the specific type of product created based on the provided configuration.
5. Flexibility: The solution should be flexible enough to handle variations in product types and configurations.

Expected Behavior:

The type definitions should ensure that when a factory function is invoked with specific configurations, the TypeScript compiler can correctly infer the type of the returned object. This means IntelliSense (autocompletion and type checking) should work as expected.

Edge Cases to Consider:

• What happens if the configuration options are optional?
• How do you handle situations where different configurations lead to different subtypes of a base product?
• Can the factory function return undefined or null under certain conditions?

Examples

Example 1: Simple Product Factory

Let's imagine a factory that creates different types of "shapes".

// Define the possible shapes
interface Circle {
  type: 'circle';
  radius: number;
}

interface Square {
  type: 'square';
  sideLength: number;
}

type Shape = Circle | Square;

// Define a configuration for creating shapes
interface ShapeConfig {
  shapeType: 'circle' | 'square';
  size: number;
}

// We need to define a type for a factory function that takes ShapeConfig
// and returns a Shape. The *exact* type of Shape returned should depend
// on shapeType.

// Expected type signature for the factory function:
// <T extends ShapeConfig>(config: T) => ... some type that depends on T.shapeType

// Example usage of such a factory (implementation not required for typing):
// declare const shapeFactory: <T extends ShapeConfig>(config: T) => Shape;
// const myCircle = shapeFactory({ shapeType: 'circle', size: 10 }); // myCircle should be Circle
// const mySquare = shapeFactory({ shapeType: 'square', size: 5 }); // mySquare should be Square

Example 2: Factory with More Complex Options

Consider a factory that creates "greetings" with different styles.

// Define possible greeting types
interface FormalGreeting {
  greeting: 'Hello';
  target: string;
  salutation: 'Mr.' | 'Ms.';
}

interface InformalGreeting {
  greeting: 'Hi';
  target: string;
  nickname?: string;
}

type Greeting = FormalGreeting | InformalGreeting;

// Define configuration options
interface GreetingOptions {
  type: 'formal' | 'informal';
  name: string;
  title?: 'Mr.' | 'Ms.'; // Only relevant for formal
  nick?: string;        // Only relevant for informal
}

// We need to define a type for a factory function that takes GreetingOptions
// and returns a Greeting. The specific type of Greeting returned should depend
// on the 'type' property of GreetingOptions.

// Expected type signature for the factory function:
// <T extends GreetingOptions>(options: T) => ... some type that depends on T.type

// Example usage of such a factory (implementation not required for typing):
// declare const greetingFactory: <T extends GreetingOptions>(options: T) => Greeting;
// const formal = greetingFactory({ type: 'formal', name: 'Smith', title: 'Mr.' }); // formal should be FormalGreeting
// const informal = greetingFactory({ type: 'informal', name: 'Alice', nick: 'Ally' }); // informal should be InformalGreeting
// const alsoInformal = greetingFactory({ type: 'informal', name: 'Bob' }); // alsoInformal should be InformalGreeting

Constraints

• The solution must be written entirely in TypeScript.
• The focus is on defining types, not on implementing the factory function logic.
• Your type definitions should allow for type narrowing based on the properties of the configuration object.
• The generated types should be clear, readable, and reusable.

Notes

• Consider using mapped types, conditional types, and discriminated unions to achieve the desired level of type precision.
• Think about how to constrain the generic type parameters of your factory function type to ensure valid configurations are accepted.
• The goal is to create type signatures that make the usage of the factory function type-safe and provide excellent developer experience through IntelliSense.