Literal Type Helpers: Crafting Precise Types

Literal type helpers in TypeScript allow you to create more specific and reusable types based on literal values. This challenge focuses on implementing a few common literal type helpers, enabling you to refine your type definitions and improve code clarity. Successfully completing this challenge will demonstrate a strong understanding of advanced TypeScript type manipulation.

Problem Description

You are tasked with implementing three literal type helper functions in TypeScript: toNumericLiteral, toBooleanLiteral, and toLiteralUnion. These functions will take a value as input and return a type that represents the literal type of that value, or a union of literal types if the input is a union.

• toNumericLiteral<T>: This function should take a value of type T and return a type that represents the literal type of that value if T is a number. If T is a union of numbers, it should return a union of the literal number types. If T is not a number (or a union of numbers), it should return never.
• toBooleanLiteral<T>: This function should take a value of type T and return a type that represents the literal type of that value if T is a boolean. If T is a union of booleans, it should return a union of the literal boolean types. If T is not a boolean (or a union of booleans), it should return never.
• toLiteralUnion<T>: This function should take a value of type T and return a type that represents the literal type of that value if T is a string literal type. If T is a union of string literal types, it should return a union of the literal string types. If T is not a string literal type (or a union of string literal types), it should return never.

Key Requirements:

• The functions must correctly infer the literal type(s) from the input value.
• The functions must handle unions of literal types correctly.
• The functions must return never if the input is not a literal type (or union of literal types) of the expected kind.
• The functions should be type-safe and provide accurate type information.

Expected Behavior:

The functions should be usable in type contexts to provide more precise type information. For example, using toNumericLiteral on the number 5 should result in the type 5. Using it on the union 5 | 10 should result in the type 5 | 10.

Examples

Example 1:

type NumericType = toNumericLiteral<5>;
// NumericType should be 5

type UnionNumericType = toNumericLiteral<5 | 10>;
// UnionNumericType should be 5 | 10

type InvalidType = toNumericLiteral<"hello">;
// InvalidType should be never

Example 2:

type BooleanType = toBooleanLiteral<true>;
// BooleanType should be true

type UnionBooleanType = toBooleanLiteral<true | false>;
// UnionBooleanType should be true | false

type InvalidBooleanType = toBooleanLiteral<5>;
// InvalidBooleanType should be never

Example 3:

type StringLiteralType = toLiteralUnion<"hello">;
// StringLiteralType should be "hello"

type UnionStringLiteralType = toLiteralUnion<"hello" | "world">;
// UnionStringLiteralType should be "hello" | "world"

type InvalidStringLiteralType = toLiteralUnion<5>;
// InvalidStringLiteralType should be never

Constraints

• The functions must be implemented using TypeScript's type system features (no runtime code).
• The functions should be generic to handle different types.
• The functions should be as efficient as possible within the constraints of TypeScript's type system. Performance is not a primary concern, but avoid unnecessary complexity.
• The input T can be a primitive type or a union of primitive types.

Notes

• Consider using conditional types and type inference to achieve the desired behavior.
• The typeof operator can be helpful for determining the type of a value.
• Think about how to handle unions of literal types correctly. TypeScript's type system provides powerful tools for working with unions.
• The goal is to create type-level functions, not runtime functions. These functions should be used in type definitions, not in code that executes.