Path-Based Set Creation in TypeScript

This challenge focuses on creating a utility function in TypeScript that constructs a set type based on a given path of string keys. This is particularly useful when dealing with deeply nested objects where you need to ensure type safety when accessing specific properties along a chain. The goal is to derive a set type representing the possible values at the end of that path.

Problem Description

You are tasked with creating a function called createSetTypeByPath that takes a path (an array of string keys) and a base type as input. The function should return a TypeScript type representing a set containing the possible values at the end of the specified path within the base type. Essentially, it should infer the type of the property at the end of the path and return Set<thatType>.

Key Requirements:

• Path Traversal: The function must correctly traverse the provided path of string keys within the base type.
• Type Inference: It should accurately infer the type of the property at the end of the path.
• Set Type Creation: The function must return a Set<inferredType> type.
• Error Handling: If the path is invalid (e.g., a key doesn't exist in the type), the function should return never.

Expected Behavior:

The function should return a type that represents a set of the type found at the end of the path. If any key in the path is not found, the function should return never.

Edge Cases to Consider:

• Empty path: Should return Set<never>.
• Path with a single key: Should return Set<type of the property>.
• Nested paths: Should correctly traverse multiple levels of nesting.
• Invalid paths: Should return never if any key is not found.
• Base type is any: Should return Set<any>.
• Base type is unknown: Should return Set<unknown>.

Examples

Example 1:

Input: path: ["user", "profile", "age"], baseType: { user: { profile: { age: number } } }
Output: Set<number>
Explanation: The path "user.profile.age" leads to a property of type number. Therefore, the function returns `Set<number>`.

Example 2:

Input: path: ["items"], baseType: { items: string[] }
Output: Set<string>
Explanation: The path "items" leads to a property of type string[].  The function returns `Set<string>`.

Example 3:

Input: path: ["name"], baseType: { address: { city: string } }
Output: never
Explanation: The path "name" does not exist in the base type. Therefore, the function returns `never`.

Example 4:

Input: path: [], baseType: { data: { value: any } }
Output: Set<never>
Explanation: An empty path should return `Set<never>`.

Constraints

• The path will be an array of strings.
• The base type will be a valid TypeScript type.
• The function should be performant enough to handle reasonably sized paths (up to 10 keys).
• The function should be written in standard TypeScript.

Notes

• Consider using TypeScript's type utility functions (e.g., Pick, Omit, typeof) to help with path traversal and type inference.
• You may need to use conditional types to handle different scenarios.
• Think about how to handle the case where a property in the path is optional. For simplicity, assume all properties are required for this challenge.
• The goal is to create a type, not a runtime value. The function should return a TypeScript type definition.
• This is a type-level problem, so you won't be executing any code during the function's operation. You're defining a type that can be used elsewhere.