Enforcing uniform data types in nested objects in TypeScript

Question

Enforcing uniform data types in nested objects in TypeScript

Currently, I am in need of generating a list of constants. For instance,

const Days = {
  YESTERDAY: -1,
  TODAY: 0,
  TOMORROW: 1,
}

I am looking for a method to restrict the types of all properties within Days. In other words, if I attempt to add a property like BAD_DAY: true, I want the compiler to raise an error.

To tackle this, I initially tried creating something along the lines of

type ObjectOf<T> = {[k: string]: T};

const Days: ObjectOf<number> = {
   A: true;
}

This approach does produce an error, but unfortunately, I do not receive type completion suggestions when typing Days.. This lack of autocompletion is due to defining it as a keyed object type.

It seems that I have to choose between having code completion similar to the first example, or compiler assistance like in the second example. Is there a way to combine both benefits? Ideally, I am aiming for functionality resembling Java Enums, where it is a predefined list of objects sharing the same type.

enum Days{
   Today("SUN"), MONDAY("MON"), TUESDAY("TUES"), WEDNESDAY("WED"),
   THURSDAY("THURS"), FRIDAY("FRI"), SATURDAY("SAT");
   private String abbreviation;
   public String getAbbreviation() {
       return this.abbreviation;
   }
   Days(String abbreviation) {
      this.abbreviation = abbreviation;
   }
}

typescript generics

Answer 1

Answer №1

Having your cake and eating it too. When dealing with the `const` keyword, you'll need a versatile helper function. This function will uphold the constraint while accurately inferring the type of the object literal being passed in:

type ObjectOf<T> = {[k: string]: T};
function createObjectOfNumber<T extends ObjectOf<number>>(v:T){
    return v;
}
const Days = createObjectOfNumber({
   A: 1
   // B: true // would result in an error
});
Days.A // valid

An alternative, more adaptable version might look like this:

function createObjectOf<TValue>(){
    return function<T extends ObjectOf<TValue>>(v:T){
        return v;
    }
}
const Days = createObjectOf<number>()({
   A: 1
   // B: true // would result in an error
});
Days.A // valid

If you're looking for something resembling Java enums in TypeScript, there isn't built-in language support for that. However, you can emulate them using techniques outlined in this response.

Answer 2

Having your cake and eating it too. When dealing with the `const` keyword, you'll need a versatile helper function. This function will uphold the constraint while accurately inferring the type of the object literal being passed in:

type ObjectOf<T> = {[k: string]: T};
function createObjectOfNumber<T extends ObjectOf<number>>(v:T){
    return v;
}
const Days = createObjectOfNumber({
   A: 1
   // B: true // would result in an error
});
Days.A // valid

An alternative, more adaptable version might look like this:

function createObjectOf<TValue>(){
    return function<T extends ObjectOf<TValue>>(v:T){
        return v;
    }
}
const Days = createObjectOf<number>()({
   A: 1
   // B: true // would result in an error
});
Days.A // valid

If you're looking for something resembling Java enums in TypeScript, there isn't built-in language support for that. However, you can emulate them using techniques outlined in this response.

Enforcing uniform data types in nested objects in TypeScript

Answer №1

Similar questions

Transforming a material-ui component from a class to a function

When attempting an Axios request, the backend method cannot be accessed

What is the best way to access the vue3datepicker object in order to manually close the date picker popup user interface?

Unable to call an object that may be 'undefined': Utilizing a function with a return object that includes asynchronous functions as properties

Prevent special characters in input fields using Angular and TypeScript

Error: Cannot access property 'tb' of an undefined value

Having trouble extracting a list of matches using a Regular Expression?

I encountered a TypeError when attempting to load MDX in Next.js with the mdx-js/react library

Managing properties of classes within callbacks using TypeScript

ngIf failing to pick up on variable updates

What is causing TypeScript to incorrectly infer rest parameters in function implementation?

Animating Angular on the table row element

An Unexpected Typescript Error Occurred While Creating an RxCollection With RxDB

Unable to find module 'child_process'

Parentheses are automatically wrapped around the implicit return of arrow functions

Choose all the checkboxes that use Knockout JS

What are the steps to incorporating the pick function in TypeScript?

Bringing in the Ionic ToastController to a TypeScript class

What is the reason behind the compiler's inability to deduce a generic parameter in instances where there is a generic return value?

When hosting on render.com, the session data is not retained when redirecting to other routes