Building Nested Data Structures with Recursive TypeScript Types

Recursive type definitions are a powerful feature in TypeScript that allow you to define types that refer to themselves. This is incredibly useful for modeling hierarchical or self-referential data structures, such as trees, linked lists, or JSON-like objects with arbitrary nesting. This challenge will guide you through creating such a type.

Problem Description

Your task is to create a TypeScript type that can represent a nested object structure where any property's value can either be a primitive type (string, number, boolean) or another nested object of the same structure. You will need to define a recursive type that allows for arbitrary levels of nesting.

Key Requirements:

• The type should be able to represent a single object.
• Each property within the object can have a value that is either a primitive type or another object conforming to the same recursive type.
• The nesting depth should be unlimited.

Expected Behavior:

You should be able to declare variables of this type and assign them valid nested object structures. TypeScript should correctly infer the types and catch any invalid assignments.

Edge Cases:

• An empty object.
• An object containing only primitive values.
• An object containing deeply nested structures.

Examples

Example 1:

// Input: A valid nested object
const validObject1 = {
  name: "Root",
  data: {
    value: 123,
    isActive: true,
  },
};

// TypeScript should accept this assignment without errors.

Example 2:

// Input: Another valid nested object with deeper nesting
const validObject2 = {
  id: "abc-123",
  settings: {
    theme: "dark",
    preferences: {
      fontSize: 14,
      layout: "compact",
    },
  },
};

// TypeScript should accept this assignment without errors.

Example 3:

// Input: An object with a non-primitive, non-object value (e.g., an array)
const invalidObject1 = {
  items: [1, 2, 3], // Arrays are not allowed as direct property values in this specific recursive type.
};

// TypeScript should flag this assignment as an error.

Constraints

• The recursive type should only allow primitive values (string, number, boolean) or nested objects of the same type as property values.
• Arrays, functions, or other complex types are not permitted as direct property values within the nested structure.
• The solution should be purely in TypeScript, leveraging its type system.

Notes

Consider how you can define a type that refers to itself. Think about the base case for the recursion and how to represent the repeating structure. You might need to use a specific TypeScript construct for defining object shapes.