Type-Level JSON Parser in TypeScript

This challenge involves creating a type-level parser for a simplified JSON-like structure. You'll leverage TypeScript's advanced type system to parse strings representing data structures into corresponding static types. This is a valuable exercise in understanding and manipulating complex type constructs, enabling compile-time validation of data structures.

Problem Description

Your task is to implement a type-level parser in TypeScript that can take a string literal representing a simplified JSON structure and transform it into a corresponding TypeScript type. The parser should handle basic JSON types: strings, numbers, booleans, null, arrays, and objects.

Key Requirements:

1. Type Parsing: Design a series of generic types that can parse a string literal into a TypeScript type.
2. Supported Types: The parser must correctly infer types for:
   • Strings: "hello" should become string.
   • Numbers: 123, 3.14, -5 should become number.
   • Booleans: true, false should become boolean.
   • Null: null should become null.
   • Arrays: [1, "two", true] should become an array type where each element's type is inferred. For example, [number, string, boolean].
   • Objects: {"name": "Alice", "age": 30, "isActive": true} should become an object type with corresponding property types.
3. String Literal Input: The input to your parser will always be a string literal type.
4. Error Handling (Implicit): If the input string is not a valid representation of the supported types, the type inference should likely result in an never or a specific error type, though explicit error types are not strictly required for this challenge. The primary goal is correct parsing of valid inputs.
5. Recursive Structures: The parser should handle nested arrays and objects.

Expected Behavior:

When you apply your parser type to a valid string literal, the resulting type should accurately reflect the structure and data types of the JSON-like input.

Edge Cases:

• Empty arrays: []
• Empty objects: {}
• Arrays containing mixed types.
• Objects with nested structures.
• Numbers with decimal points and negative signs.
• String literals that might contain escaped quotes (though for simplicity, we'll assume no escaped characters within strings for this challenge).

Examples

Example 1:

// Input String Literal Type
type Input1 = '"hello world"';

// Expected Output Type
type Output1 = string;

// Your parser applied to Input1 should yield Output1
type Parsed1 = ParseJson<Input1>; // Should be string

Explanation: The string literal "hello world" is correctly parsed into the primitive string type.

Example 2:

// Input String Literal Type
type Input2 = '{"name": "Alice", "age": 30, "isActive": true}';

// Expected Output Type
type Output2 = {
    name: string;
    age: number;
    isActive: boolean;
};

// Your parser applied to Input2 should yield Output2
type Parsed2 = ParseJson<Input2>; // Should be { name: string; age: number; isActive: boolean; }

Explanation: The object literal is parsed, with keys and their corresponding value types correctly inferred.

Example 3:

// Input String Literal Type
type Input3 = '[1, "two", null, [true, false]]';

// Expected Output Type
type Output3 = [number, string, null, [boolean, boolean]];

// Your parser applied to Input3 should yield Output3
type Parsed3 = ParseJson<Input3>; // Should be [number, string, null, [boolean, boolean]]

Explanation: The array literal with mixed types and a nested array is correctly parsed into a tuple type with inferred element types.

Example 4: (Edge Case - Empty Object)

// Input String Literal Type
type Input4 = '{}';

// Expected Output Type
type Output4 = {};

// Your parser applied to Input4 should yield Output4
type Parsed4 = ParseJson<Input4>; // Should be {}

Explanation: An empty object literal is parsed into an empty object type.

Constraints

• The input to your parser will always be a string literal type representing a valid, simplified JSON structure.
• Assume no complex escape sequences within string literals (e.g., \n, \"). Only basic string values.
• Assume valid JSON formatting (e.g., correct comma placement, no trailing commas).
• The focus is on type-level manipulation. Runtime performance is not a primary concern for this challenge.
• The input string will represent one of the following top-level structures: a primitive (string, number, boolean, null), an array, or an object.

Notes

This challenge requires a deep understanding of TypeScript's template literal types, conditional types, infer keywords, and possibly variadic tuple types.

You'll likely need to break down the parsing logic into smaller, reusable generic types for handling different parts of the JSON structure (e.g., parsing arrays, parsing objects, parsing primitives). Consider how to distinguish between different JSON types based on the input string.

Think about how to identify the start and end of different JSON structures (e.g., [, ], {, }, "). You might need to use string manipulation utilities at the type level (e.g., String.prototype.startsWith, String.prototype.endsWith, String.prototype.slice – or their type-level equivalents).