Is it possible to verify type equality in Typescript?

Question

Is it possible to verify type equality in Typescript?

If the types do not match, I want to receive an error. Here is an example of an object:

const ACTIVITY_ATTRIBUTES = {
    onsite: {
        id:  "applied",
        ....
    },
    online: {
        id: "applied_online",
        ....
    },
    ...
} as const

I want to restrict it to only strings that the server can accept

export type ContactAttribute = "applied" | "applied_online" | "donated" | "messaged" | "reviewed"

I understand that using 'as const' cannot be combined with a type constraint (as const will be ignored). Is there a way to ensure that the 'id' property matches the specified ContactAttribute type? Something like:

$Values<typeof ACTIVITY_ATTRIBUTES >["id"] === ContactAttribute

typescript

Answer 1

Answer №1

To accomplish this, we can utilize a dummy validation function.

const checkType = <T> (obj:T) => undefined

The final step is to invoke it with the specified type and object:

type ContactAttribute = "applied" | "applied_online" | "donated" | "messaged" | "reviewed"

type ActivityAttributes= {
   [k:string]: {
      id: ContactAttribute 
   }
}

const ACTIVITY_ATTRIBUTES = {
    onsite: {
        id:  "applied",
        ....
    },
    donation: {
        id: "donated",
        ....
    },
    ...
} as const

checkType<ActivityAttributes>(ACTIVITY_ATTRIBUTES) // Will display an error in case of type mismatches.

Answer 2

To accomplish this, we can utilize a dummy validation function.

const checkType = <T> (obj:T) => undefined

The final step is to invoke it with the specified type and object:

type ContactAttribute = "applied" | "applied_online" | "donated" | "messaged" | "reviewed"

type ActivityAttributes= {
   [k:string]: {
      id: ContactAttribute 
   }
}

const ACTIVITY_ATTRIBUTES = {
    onsite: {
        id:  "applied",
        ....
    },
    donation: {
        id: "donated",
        ....
    },
    ...
} as const

checkType<ActivityAttributes>(ACTIVITY_ATTRIBUTES) // Will display an error in case of type mismatches.

Answer 3

Answer №2

To ensure that only arguments with an 'id' property of type 'ContactAttribute' are accepted, I have created a helper function that preserves the argument as is without altering its type:

const hasGoodContactAttributes =
    <T extends Record<keyof T, { id: ContactAttribute }>>(t: T) => t;

You can use this function to define your ACTIVITY_ATTRIBUTES object like so:

const ACTIVITY_ATTRIBUTES = hasGoodContactAttributes({
    onsite: {
        id: "applied",
        otherProp: 123,
    },
    donation: {
        id: "donated",
        alsoOtherProp: 456
        //....
    },
    online: {
        id: "applied_online",
        //....
    },
    reviewe: {
        id: "reviewed",
        //....
    },
}); // as const if you want

If there is an error in defining the attributes, it will be caught at compile time:

const BAD_ATTRIBUTES = hasGoodContactAttributes({
    okay: {
        id: "messaged"
    },
    oops: {
        id: "reviewed_online" // error!
    //  ~~ <-- '"reviewed_online"' is not assignable to type 'ContactAttribute'
    }
})

I hope this explanation helps you out; best of luck!

Link to code

Answer 4

To ensure that only arguments with an 'id' property of type 'ContactAttribute' are accepted, I have created a helper function that preserves the argument as is without altering its type:

const hasGoodContactAttributes =
    <T extends Record<keyof T, { id: ContactAttribute }>>(t: T) => t;

You can use this function to define your ACTIVITY_ATTRIBUTES object like so:

const ACTIVITY_ATTRIBUTES = hasGoodContactAttributes({
    onsite: {
        id: "applied",
        otherProp: 123,
    },
    donation: {
        id: "donated",
        alsoOtherProp: 456
        //....
    },
    online: {
        id: "applied_online",
        //....
    },
    reviewe: {
        id: "reviewed",
        //....
    },
}); // as const if you want

If there is an error in defining the attributes, it will be caught at compile time:

const BAD_ATTRIBUTES = hasGoodContactAttributes({
    okay: {
        id: "messaged"
    },
    oops: {
        id: "reviewed_online" // error!
    //  ~~ <-- '"reviewed_online"' is not assignable to type 'ContactAttribute'
    }
})

I hope this explanation helps you out; best of luck!

Link to code

Answer 5

Answer №3

If you're looking for a simpler way to accomplish this, I recommend checking out this StackOverflow post.

Here's an example:

const ACTIVITY_ATTRIBUTES = {
    onsite: {
        id:  "applied",
    },
    donation: {
        id: "donated",
    },
    online: {
        id: "applied_online",
    },
    reviewe: {
        id: "reviewed",
    },
}

export type ContactAttribute = "applied" | "applied_online" | "donated" | "messaged" | "reviewed"

function isOfTypeContact (inputId: string): inputId is ContactAttribute {
    return ["applied", "applied_online", "donated", "messaged", "reviewed"].includes(inputId);
}

console.log(isOfTypeContact(ACTIVITY_ATTRIBUTES.onsite.id)) // true

This should do the trick.

Answer 6

If you're looking for a simpler way to accomplish this, I recommend checking out this StackOverflow post.

Here's an example:

const ACTIVITY_ATTRIBUTES = {
    onsite: {
        id:  "applied",
    },
    donation: {
        id: "donated",
    },
    online: {
        id: "applied_online",
    },
    reviewe: {
        id: "reviewed",
    },
}

export type ContactAttribute = "applied" | "applied_online" | "donated" | "messaged" | "reviewed"

function isOfTypeContact (inputId: string): inputId is ContactAttribute {
    return ["applied", "applied_online", "donated", "messaged", "reviewed"].includes(inputId);
}

console.log(isOfTypeContact(ACTIVITY_ATTRIBUTES.onsite.id)) // true

This should do the trick.

Answer 7

Answer №4

To achieve this desired outcome, you can utilize a combination of the declare keyword and dead code. Using declare statements allows us to set up artificial "values" for our types at compile time. Subsequently, we employ a dead code block to invoke a function that accepts two parameters of identical type.

type T1 = number;
type T2 = string;

declare const dummy1: T1;
declare const dummy2: T2;
declare function sameType<T>(v1: T, v2: T): void;
if (false) {
    // @ts-ignore: Unreachable code
    sameType(
        // ensure no line break occurs to apply ts-ignore properly
        dummy1, dummy2);
}

The use of @ts-ignore suppresses the warning pertaining to unreachable code.

An additional line comment following the opening parenthesis serves to prevent tools like prettier from formatting the arguments on the same line, ultimately maintaining the error-triggering scenario.

Another approach involves utilizing an as expression for a more concise solution.

type T1 = number;
type T2 = string;

declare const dummy1: T1;
if (false) {
    // @ts-ignore: Unreachable code
    dummy1 
        // ensure no line break occurs to apply ts-ignore properly
        as T2
}

Answer 8

To achieve this desired outcome, you can utilize a combination of the declare keyword and dead code. Using declare statements allows us to set up artificial "values" for our types at compile time. Subsequently, we employ a dead code block to invoke a function that accepts two parameters of identical type.

type T1 = number;
type T2 = string;

declare const dummy1: T1;
declare const dummy2: T2;
declare function sameType<T>(v1: T, v2: T): void;
if (false) {
    // @ts-ignore: Unreachable code
    sameType(
        // ensure no line break occurs to apply ts-ignore properly
        dummy1, dummy2);
}

The use of @ts-ignore suppresses the warning pertaining to unreachable code.

An additional line comment following the opening parenthesis serves to prevent tools like prettier from formatting the arguments on the same line, ultimately maintaining the error-triggering scenario.

Another approach involves utilizing an as expression for a more concise solution.

type T1 = number;
type T2 = string;

declare const dummy1: T1;
if (false) {
    // @ts-ignore: Unreachable code
    dummy1 
        // ensure no line break occurs to apply ts-ignore properly
        as T2
}

Answer 9

Answer №5

If you want to achieve the desired outcome, you can utilize the code snippet below:

const ACTIVITY_ATTRIBUTES: {[key: string]: {id: ContactAttribute}} = {
    onsite: {
        id:  "applied",
    },
    donation: {
        id: "donated",
    },
    online: {
        id: "applied_online",
    },
    reviewe: {
        id: "reviewed",
    },
    hi: {
      id: 'applied',
    }
} as const

type ContactAttribute = "applied" | "applied_online" | "donated" | "messaged" | "reviewed"

However, it is advisable to incorporate additional typechecking measures because even though the id is validated, there could still be discrepancies with other properties associated with each id.

To address this concern, consider implementing a discriminated union.

Here's an example:

type Contact = {
  id: "applied",
  x: string
} | {
  id: "applied_online"
  y: number
}

Utilizing this method ensures that the correct properties linked to each ContactAttribute are initialized accurately.

Answer 10

If you want to achieve the desired outcome, you can utilize the code snippet below:

const ACTIVITY_ATTRIBUTES: {[key: string]: {id: ContactAttribute}} = {
    onsite: {
        id:  "applied",
    },
    donation: {
        id: "donated",
    },
    online: {
        id: "applied_online",
    },
    reviewe: {
        id: "reviewed",
    },
    hi: {
      id: 'applied',
    }
} as const

type ContactAttribute = "applied" | "applied_online" | "donated" | "messaged" | "reviewed"

However, it is advisable to incorporate additional typechecking measures because even though the id is validated, there could still be discrepancies with other properties associated with each id.

To address this concern, consider implementing a discriminated union.

Here's an example:

type Contact = {
  id: "applied",
  x: string
} | {
  id: "applied_online"
  y: number
}

Utilizing this method ensures that the correct properties linked to each ContactAttribute are initialized accurately.

Answer 11

Answer №6

declare type IsEqual<X, Y> = X extends Y ? (Y extends X ? true : false) : false;

const checkEquality: IsEqual<TypeOne, TypeTwo> = true;

Answer 12

declare type IsEqual<X, Y> = X extends Y ? (Y extends X ? true : false) : false;

const checkEquality: IsEqual<TypeOne, TypeTwo> = true;

Is it possible to verify type equality in Typescript?

Answer №1

Answer №2

Answer №3

Answer №4

Answer №5

Answer №6

Similar questions

What is the best way to ensure that multiple queries are returned in the correct sequence?

Problem encountered while implementing callbacks in redux-saga

Guide to encoding an array of objects into a URI-friendly query string using TypeScript

Using the hook to implement the useContext function in React

What is the best way to reload a React/TypeScript page after submitting a POST request?

When trying to run ionic serve, I encountered the following error: "[ERROR] ng has unexpectedly closed with an exit code of 127."

The chart JS label callback requires a specified type declaration

Error encountered: "Unable to locate module 'typescript-Collections' when modifying the module to "umd" or "amd" in the tsconfig.json file."

Creating an Angular table using reactive forms: a step-by-step guide

What is the best way to troubleshoot the type of data being sent to the subscriber of an Angular observable?

Exporting ExpressJS from a TypeScript wrapper in NodeJS

Adjust puppeteer window dimensions when running in non-headless mode (not viewport)

What sets typescript apart when using a getter versus a regular function?

ng serve issue persists even after resolving vulnerabilities

Angular 10 introduces a new approach to handling concurrency called "forkJoin"

Combining pixijs with TypeScript in Ionic 2 using npm

Creating a unique object by dynamically incorporating features from another object

Breaking up and Substituting text within Angular 8's HTML structure

Navigating collisions in the ECS architecture: Best practices

Guide to separating the bytes of a number and placing them into an Uint8Array