Dynamic Path Type Generation from Object in TypeScript

This challenge focuses on creating a utility type in TypeScript that dynamically generates a type representing a path within a given object. This is incredibly useful for creating type-safe accessors or deeply nested property lookups, ensuring that your code is robust and catches errors at compile time rather than runtime. You'll be building a type that takes an object and a string path as input and returns a type representing the value at that path.

Problem Description

You need to create a TypeScript type called PathType<T, P> where:

• T is the input object type.
• P is a string representing the path to a property within the object, using dot notation (e.g., "a.b.c").

The PathType<T, P> type should resolve to the type of the property located at the specified path within the object T. If the path does not exist, the type should resolve to never.

Key Requirements:

• Dynamic Path Resolution: The type must correctly resolve the type at any valid dot-notation path within the object.
• never for Invalid Paths: If the path doesn't exist in the object, the resulting type should be never.
• Handles Nested Objects: The type must correctly traverse nested objects within the path.
• Handles Primitive Types: The type must correctly resolve to primitive types (string, number, boolean, etc.) if the path leads to a primitive value.

Expected Behavior:

Given an object and a path, the type should return the type of the property at that path. The type should be inferrable at compile time.

Edge Cases to Consider:

• Empty path (""): Should resolve to T (the entire object type).
• Path with a single property (e.g., "a"): Should resolve to the type of the property "a" in the object.
• Path with multiple nested properties (e.g., "a.b.c"): Should resolve to the type of the property "c" within the object at "a.b".
• Non-existent path (e.g., "a.b.c" when "b" doesn't exist): Should resolve to never.
• Object with optional properties. The type should still work correctly.

Examples

Example 1:

type MyObject = {
  a: string;
  b: {
    c: number;
    d?: boolean;
  };
};

type PathResult1 = PathType<MyObject, "a">; // Expected: string
type PathResult2 = PathType<MyObject, "b.c">; // Expected: number
type PathResult3 = PathType<MyObject, "b.d">; // Expected: boolean | undefined
type PathResult4 = PathType<MyObject, "b.e">; // Expected: never
type PathResult5 = PathType<MyObject, "a.b">; // Expected: never
type PathResult6 = PathType<MyObject, "" >; // Expected: MyObject

Example 2:

type AnotherObject = {
  name: string;
  age: number;
  address: {
    street: string;
    city: string;
  };
};

type PathResult7 = PathType<AnotherObject, "name">; // Expected: string
type PathResult8 = PathType<AnotherObject, "address.city">; // Expected: string
type PathResult9 = PathType<AnotherObject, "address.zip">; // Expected: never

Example 3: (Edge Case - Empty Object)

type EmptyObject = {};

type PathResult10 = PathType<EmptyObject, "a">; // Expected: never
type PathResult11 = PathType<EmptyObject, "" >; // Expected: EmptyObject

Constraints

• The path P will always be a string.
• The path P will use dot notation (e.g., "a.b.c").
• The object T can be any valid TypeScript object type.
• The solution should be a type definition, not a function.
• The solution should be as type-safe as possible.

Notes

Consider using conditional types and recursion to traverse the object based on the path string. You might find it helpful to split the path string into an array of property names. Think about how to handle the base case of the recursion (when the path is empty or a property doesn't exist). The goal is to create a reusable and robust type that can be used in various scenarios where you need to access deeply nested properties in a type-safe manner.