Using TypeScript to explicitly define a subtype

Question

Using TypeScript to explicitly define a subtype

Given a base type A, I am looking to create a sub-type B that is assignable to A without any additional properties, and enforce this assignability.

Illustration

Starting with the following type:

interface A {
  name?: string;
  age?: number;
}

I aim to establish the following type:

interface B {
  name: string;
}

In essence, any instance of type B should be assignable to type A, maintaining strict adherence. If any extra property is added, TypeScript should raise an error.

Potential Pitfalls

Utilizing extends might lead to a less stringent result than desired:

interface B extends A {
  name: string;
}

This formulates as:

interface B {
  name: string;
  age?: number;
}

Furthermore, it permits adding non-existent properties for Person.

The approach of A extends B is not viable due to A already being predetermined; the goal is to craft type B.

typescript

Answer 1

Answer №1

When looking for specific fields that already exist in A, an alternative method to consider would be:

type OnlyExisting<X, Y extends X> = {
  [Key in keyof Y]: Key extends keyof X ? Y[Key] : never;
}

type D = OnlyExisting<A, { age: number; }>;

This approach does not prevent you from defining

type E = OnlyExisting<A, {
  age: number;
  bar: string;
}>;

// E results in { age: number; bar: never }

However, it ensures type safety by instructing TypeScript to overlook fields that do not appear in X. Therefore, any function expecting A should still welcome E without issues;

Answer 2

When looking for specific fields that already exist in A, an alternative method to consider would be:

type OnlyExisting<X, Y extends X> = {
  [Key in keyof Y]: Key extends keyof X ? Y[Key] : never;
}

type D = OnlyExisting<A, { age: number; }>;

This approach does not prevent you from defining

type E = OnlyExisting<A, {
  age: number;
  bar: string;
}>;

// E results in { age: number; bar: never }

However, it ensures type safety by instructing TypeScript to overlook fields that do not appear in X. Therefore, any function expecting A should still welcome E without issues;

Using TypeScript to explicitly define a subtype

Illustration

Potential Pitfalls

Answer №1

Similar questions

incorporating a personalized HTMLElement using Typescript

The parent component remains visible in the Angular router

Generating Enums from JSON REST API in Angular 8

Determining whether a variable is an instance of FirebaseApp

Mongoose TypeScript Aggregation error: is not a valid property of type 'any[]'

Obtain the user's ID in string format from the clerk

How to transform a file into a uInt8Array using Angular

The information that is visible in the console is failing to appear in the view

Change the initial characters of a string according to specific categories

Creating nested return types: A guide to defining function return types within a Typescript class

Having trouble retrieving spot price using Uniswap SDK due to a transaction error LOK

Why do I keep encountering the error "global is not defined" when using Angular with amazon-cognito-identity-js?

How can I create a computed field in TypeORM by deriving its value from other fields within the same Entity?

What is the best way to combine two observables in Angular using RxJS?

Angular error TS2322 arises when attempting to assign a type of 'Observable<{}>' with the share() operator

Unpacking and reassigning variables in Vue.js 3 using TypeScript

The Angular TypeScript lexicon scope becomes obscured when nested within a third-party API event handler function

I keep getting the error message "Element is missing a 'key' prop", even though I have already included a key in my loop. What could be the issue here?

Steps to develop a sub-route specifically for a single word

Utilizing Generic Types in React TypeScript Functional Components