Creating Utility Helpers with as const in TypeScript

This challenge focuses on leveraging TypeScript's as const assertion to create immutable helper objects and arrays. as const is a powerful tool for ensuring type safety and preventing accidental modification of data, which is particularly useful when defining constants or utility functions that should not change their values. Successfully completing this challenge will demonstrate your understanding of advanced TypeScript type manipulation and immutability.

Problem Description

You are tasked with creating a set of utility helper objects and arrays using TypeScript and the as const assertion. These helpers should represent common configurations or data structures that are intended to be immutable. The goal is to define these helpers in a way that TypeScript enforces their immutability, preventing accidental modifications at runtime. You should create three distinct helpers:

1. Colors: An object representing a set of predefined color names and their corresponding hex codes.
2. Directions: An array of strings representing cardinal directions (North, South, East, West).
3. Sizes: An object representing different sizes with associated numerical values (e.g., Small: 10, Medium: 20, Large: 30).

Each helper should be defined using as const to ensure immutability. Your solution should include type definitions for each helper to clearly specify their structure and types. The solution should also include a function that attempts to modify one of the helpers and demonstrates that TypeScript correctly identifies this as an error.

Examples

Example 1: Colors

Input:  No direct input, defining the Colors helper.
Output:  A type-safe, immutable object representing colors.
Explanation: The `Colors` object is defined using `as const`, ensuring that its properties (color names and hex codes) cannot be modified after initialization.

Example 2: Directions

Input: No direct input, defining the Directions helper.
Output: A type-safe, immutable array of strings.
Explanation: The `Directions` array is defined using `as const`, ensuring that its elements cannot be modified after initialization.

Example 3: Attempting to Modify Sizes

Input:  An attempt to change the value associated with the 'Medium' key in the Sizes object.
Output:  A TypeScript compiler error indicating that the property 'Medium' does not exist on type 'readonly { Small: 10; Medium: 20; Large: 30; }'.
Explanation: Because `Sizes` is defined with `as const`, TypeScript prevents modification of its properties, resulting in a compile-time error.

Constraints

• All helpers must be defined using the as const assertion.
• The Colors object must have at least three color-hex code pairs.
• The Directions array must contain exactly four directions.
• The Sizes object must have at least three size-value pairs.
• The modification attempt must be a direct assignment to a property of one of the helpers.
• The solution must compile without errors when the modification attempt is commented out.

Notes

• as const creates a type that represents a readonly version of the expression it's applied to.
• Consider the implications of immutability and how it can improve code reliability.
• Think about how as const affects the types of the resulting objects and arrays.
• The modification attempt is primarily to demonstrate that as const is working as expected. You don't need to handle the error at runtime; the TypeScript compiler should catch it.