Skip to content
BranchesTags

Repository files navigation



npm dependentsnpm downloads

Many of the types here should have been built-in. You can help by suggesting some of them to the TypeScript project.

Either add this package as a dependency or copy-paste the needed types. No credit required. 👌

PR welcome for additional commonly needed types and docs improvements. Read the contributing guidelines first.

Help wanted with reviewing proposals and pull requests.

Install

npm install type-fest

Requires TypeScript >=5.1

Works best with {strict: true} in your tsconfig.

Usage

importtype{Except}from'type-fest';typeFoo={unicorn: string;rainbow: boolean;};typeFooWithoutRainbow=Except<Foo,'rainbow'>;//=> {unicorn: string}

API

Click the type names for complete docs.

Basic

Utilities

  • EmptyObject - Represents a strictly empty plain object, the {} value.
  • IsEmptyObject - Returns a boolean for whether the type is strictly equal to an empty plain object, the {} value.
  • NonEmptyObject - Represents an object with at least 1 non-optional key.
  • UnknownRecord - Represents an object with unknown value. You probably want this instead of {}.
  • UnknownArray - Represents an array with unknown value.
  • Except - Create a type from an object type without certain keys. This is a stricter version of Omit.
  • Writable - Create a type that strips readonly from the given type. Inverse of Readonly<T>.
  • WritableDeep - Create a deeply mutable version of an object/ReadonlyMap/ReadonlySet/ReadonlyArray type. The inverse of ReadonlyDeep<T>. Use Writable<T> if you only need one level deep.
  • Merge - Merge two types into a new type. Keys of the second type overrides keys of the first type.
  • MergeDeep - Merge two objects or two arrays/tuples recursively into a new type.
  • MergeExclusive - Create a type that has mutually exclusive keys.
  • OverrideProperties - Override only existing properties of the given type. Similar to Merge, but enforces that the original type has the properties you want to override.
  • RequireAtLeastOne - Create a type that requires at least one of the given keys.
  • RequireExactlyOne - Create a type that requires exactly a single key of the given keys and disallows more.
  • RequireAllOrNone - Create a type that requires all of the given keys or none of the given keys.
  • RequireOneOrNone - Create a type that requires exactly a single key of the given keys and disallows more, or none of the given keys.
  • RequiredDeep - Create a deeply required version of another type. Use Required<T> if you only need one level deep.
  • PickDeep - Pick properties from a deeply-nested object. Use Pick<T> if you only need one level deep.
  • OmitIndexSignature - Omit any index signatures from the given object type, leaving only explicitly defined properties.
  • PickIndexSignature - Pick only index signatures from the given object type, leaving out all explicitly defined properties.
  • PartialDeep - Create a deeply optional version of another type. Use Partial<T> if you only need one level deep.
  • PartialOnUndefinedDeep - Create a deep version of another type where all keys accepting undefined type are set to optional.
  • UndefinedOnPartialDeep - Create a deep version of another type where all optional keys are set to also accept undefined.
  • ReadonlyDeep - Create a deeply immutable version of an object/Map/Set/Array type. Use Readonly<T> if you only need one level deep.
  • LiteralUnion - Create a union type by combining primitive types and literal types without sacrificing auto-completion in IDEs for the literal type part of the union. Workaround for Microsoft/TypeScript#29729.
  • Tagged - Create a tagged type that can support multiple tags if needed.
  • UnwrapTagged - Get the untagged portion of a tagged type created with Tagged.
  • Opaque - Create a tagged type. This implementation only supports a single tag.
  • UnwrapOpaque - Get the untagged portion of a tagged type created with Opaque or Tagged.
  • InvariantOf - Create an invariant type, which is a type that does not accept supertypes and subtypes.
  • SetOptional - Create a type that makes the given keys optional.
  • SetReadonly - Create a type that makes the given keys readonly.
  • SetRequired - Create a type that makes the given keys required.
  • SetNonNullable - Create a type that makes the given keys non-nullable.
  • ValueOf - Create a union of the given object's values, and optionally specify which keys to get the values from.
  • ConditionalKeys - Extract keys from a shape where values extend the given Condition type.
  • ConditionalPick - Like Pick except it selects properties from a shape where the values extend the given Condition type.
  • ConditionalPickDeep - Like ConditionalPick except that it selects the properties deeply.
  • ConditionalExcept - Like Omit except it removes properties from a shape where the values extend the given Condition type.
  • UnionToIntersection - Convert a union type to an intersection type.
  • LiteralToPrimitive - Convert a literal type to the primitive type it belongs to.
  • LiteralToPrimitiveDeep - Like LiteralToPrimitive except it converts literal types inside an object or array deeply.
  • Stringified - Create a type with the keys of the given type changed to string type.
  • IterableElement - Get the element type of an Iterable/AsyncIterable. For example, an array or a generator.
  • Entry - Create a type that represents the type of an entry of a collection.
  • Entries - Create a type that represents the type of the entries of a collection.
  • SetReturnType - Create a function type with a return type of your choice and the same parameters as the given function type.
  • SetParameterType - Create a function that replaces some parameters with the given parameters.
  • Simplify - Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
  • Get - Get a deeply-nested property from an object using a key path, like Lodash's .get() function.
  • StringKeyOf - Get keys of the given type as strings.
  • Schema - Create a deep version of another object type where property values are recursively replaced into a given value type.
  • Exact - Create a type that does not allow extra properties.
  • OptionalKeysOf - Extract all optional keys from the given type.
  • KeysOfUnion - Create a union of all keys from a given type, even those exclusive to specific union members.
  • HasOptionalKeys - Create a true/false type depending on whether the given type has any optional fields.
  • RequiredKeysOf - Extract all required keys from the given type.
  • HasRequiredKeys - Create a true/false type depending on whether the given type has any required fields.
  • ReadonlyKeysOf - Extract all readonly keys from the given type.
  • HasReadonlyKeys - Create a true/false type depending on whether the given type has any readonly fields.
  • WritableKeysOf - Extract all writable (non-readonly) keys from the given type.
  • HasWritableKeys - Create a true/false type depending on whether the given type has any writable fields.
  • Spread - Mimic the type inferred by TypeScript when merging two objects or two arrays/tuples using the spread syntax.
  • IsEqual - Returns a boolean for whether the two given types are equal.
  • TaggedUnion - Create a union of types that share a common discriminant property.
  • IntRange - Generate a union of numbers.
  • ArrayIndices - Provides valid indices for a constant array or tuple.
  • ArrayValues - Provides all values for a constant array or tuple.
  • SetFieldType - Create a type that changes the type of the given keys.
  • Paths - Generate a union of all possible paths to properties in the given object.

Type Guard

IsType vs. IfType

For every IsT type (e.g. IsAny), there is an associated IfT type that can help simplify conditional types. While the IsT types return a boolean, the IfT types act like an If/Else - they resolve to the given TypeIfT or TypeIfNotT depending on whether IsX is true or not. By default, IfT returns a boolean:

typeIfAny<T,TypeIfAny=true,TypeIfNotAny=false>=(IsAny<T>extendstrue ? TypeIfAny : TypeIfNotAny);

Usage

importtype{IsAny,IfAny}from'type-fest';typeShouldBeTrue=IsAny<any>extendstrue ? true : false;//=> truetypeShouldBeFalse=IfAny<'not any'>;//=> falsetypeShouldBeNever=IfAny<'not any','not never','never'>;//=> 'never'

JSON

  • Jsonify - Transform a type to one that is assignable to the JsonValue type.
  • Jsonifiable - Matches a value that can be losslessly converted to JSON.
  • JsonPrimitive - Matches a JSON primitive.
  • JsonObject - Matches a JSON object.
  • JsonArray - Matches a JSON array.
  • JsonValue - Matches any valid JSON value.

Async

  • Promisable - Create a type that represents either the value or the value wrapped in PromiseLike.
  • AsyncReturnType - Unwrap the return type of a function that returns a Promise.
  • Asyncify - Create an async version of the given function type.

String

  • Trim - Remove leading and trailing spaces from a string.
  • Split - Represents an array of strings split using a given character or character set.
  • Replace - Represents a string with some or all matches replaced by a replacement.

Array

  • Includes - Returns a boolean for whether the given array includes the given item.
  • Join - Join an array of strings and/or numbers using the given string as a delimiter.
  • LastArrayElement - Extracts the type of the last element of an array.
  • FixedLengthArray - Create a type that represents an array of the given type and length.
  • MultidimensionalArray - Create a type that represents a multidimensional array of the given type and dimensions.
  • MultidimensionalReadonlyArray - Create a type that represents a multidimensional readonly array of the given type and dimensions.
  • ReadonlyTuple - Create a type that represents a read-only tuple of the given type and length.
  • TupleToUnion - Convert a tuple/array into a union type of its elements.

Numeric

Change case

Miscellaneous

Declined types

If we decline a type addition, we will make sure to document the better solution here.

  • Diff and Spread - The pull request author didn't provide any real-world use-cases and the PR went stale. If you think this type is useful, provide some real-world use-cases and we might reconsider.
  • Dictionary - You only save a few characters (Dictionary<number> vs Record<string, number>) from Record, which is more flexible and well-known. Also, you shouldn't use an object as a dictionary. We have Map in JavaScript now.
  • ExtractProperties and ExtractMethods - The types violate the single responsibility principle. Instead, refine your types into more granular type hierarchies.
  • Url2Json - Inferring search parameters from a URL string is a cute idea, but not very useful in practice, since search parameters are usually dynamic and defined separately.
  • Nullish - The type only saves a couple of characters, not everyone knows what "nullish" means, and I'm also trying to get away from null.
  • TitleCase - It's not solving a common need and is a better fit for a separate package.
  • ExtendOr and ExtendAnd - The benefits don't outweigh having to learn what they mean.
  • PackageJsonExtras - There are too many possible configurations that can be put into package.json. If you would like to extend PackageJson to support an additional configuration in your project, please see the Extending existing types section below.

Alternative type names

If you know one of our types by a different name, add it here for discovery.

Tips

Extending existing types

  • PackageJson - There are a lot of tools that place extra configurations inside the package.json file. You can extend PackageJson to support these additional configurations.

    Example

    Playground

    importtype{PackageJsonasBasePackageJson}from'type-fest';importtype{Linter}from'eslint';typePackageJson=BasePackageJson&{eslintConfig?: Linter.Config};

Related

Built-in types

There are many advanced types most users don't know about.

  • Partial<T> - Make all properties in T optional.

    Example

    Playground

    interfaceNodeConfig{appName: string;port: number;}classNodeAppBuilder{privateconfiguration: NodeConfig={appName: 'NodeApp',port: 3000};privateupdateConfig<KeyextendskeyofNodeConfig>(key: Key,value: NodeConfig[Key]){this.configuration[key]=value;}config(config: Partial<NodeConfig>){typeNodeConfigKey=keyofNodeConfig;for(constkeyofObject.keys(config)asNodeConfigKey[]){constupdateValue=config[key];if(updateValue===undefined){continue;}this.updateConfig(key,updateValue);}returnthis;}}// `Partial<NodeConfig>`` allows us to provide only a part of the// NodeConfig interface.newNodeAppBuilder().config({appName: 'ToDoApp'});

  • Required<T> - Make all properties in T required.

    Example

    Playground

    interfaceContactForm{email?: string;message?: string;}functionsubmitContactForm(formData: Required<ContactForm>){// Send the form data to the server.}submitContactForm({email: 'ex@mple.com',message: 'Hi! Could you tell me more about…',});// TypeScript error: missing property 'message'submitContactForm({email: 'ex@mple.com',});

  • Readonly<T> - Make all properties in T readonly.

    Example

    Playground

    enumLogLevel{Off,Debug,Error,Fatal};interfaceLoggerConfig{name: string;level: LogLevel;}classLogger{config: Readonly<LoggerConfig>;constructor({name, level}: LoggerConfig){this.config={name, level};Object.freeze(this.config);}}constconfig: LoggerConfig={name: 'MyApp',level: LogLevel.Debug};constlogger=newLogger(config);// TypeScript Error: cannot assign to read-only property.logger.config.level=LogLevel.Error;// We are able to edit config variable as we please.config.level=LogLevel.Error;

  • Pick<T, K> - From T, pick a set of properties whose keys are in the union K.

    Example

    Playground

    interfaceArticle{title: string;thumbnail: string;content: string;}// Creates new type out of the `Article` interface composed// from the Articles' two properties: `title` and `thumbnail`.// `ArticlePreview = {title: string; thumbnail: string}`typeArticlePreview=Pick<Article,'title'|'thumbnail'>;// Render a list of articles using only title and description.functionrenderArticlePreviews(previews: ArticlePreview[]): HTMLElement{constarticles=document.createElement('div');for(constpreviewofpreviews){// Append preview to the articles.}returnarticles;}constarticles=renderArticlePreviews([{title: 'TypeScript tutorial!',thumbnail: '/assets/ts.jpg'}]);

  • Record<K, T> - Construct a type with a set of properties K of type T.

    Example

    Playground

    // Positions of employees in our company.typeMemberPosition='intern'|'developer'|'tech-lead';// Interface describing properties of a single employee.interfaceEmployee{firstName: string;lastName: string;yearsOfExperience: number;}// Create an object that has all possible `MemberPosition` values set as keys.// Those keys will store a collection of Employees of the same position.constteam: Record<MemberPosition,Employee[]>={intern: [],developer: [],'tech-lead': [],};// Our team has decided to help John with his dream of becoming Software Developer.team.intern.push({firstName: 'John',lastName: 'Doe',yearsOfExperience: 0});// `Record` forces you to initialize all of the property keys.// TypeScript Error: "tech-lead" property is missingconstteamEmpty: Record<MemberPosition,null>={intern: null,developer: null,};

  • Exclude<T, U> - Exclude from T those types that are assignable to U.

    Example

    Playground

    interfaceServerConfig{port: null|string|number;}typeRequestHandler=(request: Request,response: Response)=>void;// Exclude `null` type from `null | string | number`.// In case the port is equal to `null`, we will use default value.functiongetPortValue(port: Exclude<ServerConfig['port'],null>): number{if(typeofport==='string'){returnparseInt(port,10);}returnport;}functionstartServer(handler: RequestHandler,config: ServerConfig): void{constserver=require('http').createServer(handler);constport=config.port===null ? 3000 : getPortValue(config.port);server.listen(port);}

  • Extract<T, U> - Extract from T those types that are assignable to U.

    Example

    Playground

    declarefunctionuniqueId(): number;constID=Symbol('ID');interfacePerson{[ID]: number;name: string;age: number;}// Allows changing the person data as long as the property key is of string type.functionchangePersonData<ObjextendsPerson,KeyextendsExtract<keyofPerson,string>,ValueextendsObj[Key]>(obj: Obj,key: Key,value: Value): void{obj[key]=value;}// Tiny Andrew was born.constandrew={[ID]: uniqueId(),name: 'Andrew',age: 0,};// Cool, we're fine with that.changePersonData(andrew,'name','Pony');// Government didn't like the fact that you wanted to change your identity.changePersonData(andrew,ID,uniqueId());

  • NonNullable<T> - Exclude null and undefined from T.

    Example Works with strictNullChecks set to true.

    Playground

    typePortNumber=string|number|null;/** Part of a class definition that is used to build a server */classServerBuilder{portNumber!: NonNullable<PortNumber>;port(this: ServerBuilder,port: PortNumber): ServerBuilder{if(port==null){this.portNumber=8000;}else{this.portNumber=port;}returnthis;}}constserverBuilder=newServerBuilder();serverBuilder.port('8000')// portNumber = '8000'.port(null)// portNumber = 8000.port(3000);// portNumber = 3000// TypeScript errorserverBuilder.portNumber=null;

  • Parameters<T> - Obtain the parameters of a function type in a tuple.

    Example

    Playground

    functionshuffle(input: any[]): void{// Mutate array randomly changing its' elements indexes.}functioncallNTimes<Fnextends(...arguments_: any[])=>any>(func: Fn,callCount: number){// Type that represents the type of the received function parameters.typeFunctionParameters=Parameters<Fn>;returnfunction(...arguments_: FunctionParameters){for(leti=0;i<callCount;i++){func(...arguments_);}}}constshuffleTwice=callNTimes(shuffle,2);

  • ConstructorParameters<T> - Obtain the parameters of a constructor function type in a tuple.

    Example

    Playground

    classArticleModel{title: string;content?: string;constructor(title: string){this.title=title;}}classInstanceCache<Textends(new(...arguments_: any[])=>any)>{privateClassConstructor: T;privatecache: Map<string,InstanceType<T>>=newMap();constructor(ctr: T){this.ClassConstructor=ctr;}getInstance(...arguments_: ConstructorParameters<T>): InstanceType<T>{consthash=this.calculateArgumentsHash(...arguments_);constexistingInstance=this.cache.get(hash);if(existingInstance!==undefined){returnexistingInstance;}returnnewthis.ClassConstructor(...arguments_);}privatecalculateArgumentsHash(...arguments_: any[]): string{// Calculate hash.return'hash';}}constarticleCache=newInstanceCache(ArticleModel);constamazonArticle=articleCache.getInstance('Amazon forests burning!');

  • ReturnType<T> - Obtain the return type of a function type.

    Example

    Playground

    /** Provides every element of the iterable `iter` into the `callback` function and stores the results in an array. */functionmapIter<Elem,Funcextends(elem: Elem)=>any,RetextendsReturnType<Func>>(iter: Iterable<Elem>,callback: Func): Ret[]{constmapped: Ret[]=[];for(constelemofiter){mapped.push(callback(elem));}returnmapped;}constsetObject: Set<string>=newSet();constmapObject: Map<number,string>=newMap();mapIter(setObject,(value: string)=>value.indexOf('Foo'));// number[]mapIter(mapObject,([key,value]: [number,string])=>{returnkey%2===0 ? value : 'Odd';});// string[]

  • InstanceType<T> - Obtain the instance type of a constructor function type.

    Example

    Playground

    classIdleService{doNothing(): void{}}classNews{title: string;content: string;constructor(title: string,content: string){this.title=title;this.content=content;}}constinstanceCounter: Map<Function,number>=newMap();interfaceConstructor{new(...arguments_: any[]): any;}// Keep track how many instances of `Constr` constructor have been created.functiongetInstance<ConstrextendsConstructor,ArgumentsextendsConstructorParameters<Constr>>(constructor: Constr, ...arguments_: Arguments): InstanceType<Constr>{letcount=instanceCounter.get(constructor)||0;constinstance=newconstructor(...arguments_);instanceCounter.set(constructor,count+1);console.log(`Created ${count+1} instances of ${Constr.name} class`);returninstance;}constidleService=getInstance(IdleService);// Will log: `Created 1 instances of IdleService class`constnewsEntry=getInstance(News,'New ECMAScript proposals!','Last month...');// Will log: `Created 1 instances of News class`

  • Omit<T, K> - Constructs a type by picking all properties from T and then removing K.

    Example

    Playground

    interfaceAnimal{imageUrl: string;species: string;images: string[];paragraphs: string[];}// Creates new type with all properties of the `Animal` interface// except 'images' and 'paragraphs' properties. We can use this// type to render small hover tooltip for a wiki entry list.typeAnimalShortInfo=Omit<Animal,'images'|'paragraphs'>;functionrenderAnimalHoverInfo(animals: AnimalShortInfo[]): HTMLElement{constcontainer=document.createElement('div');// Internal implementation.returncontainer;}

  • Uppercase<S extends string> - Transforms every character in a string into uppercase.

    Example 
    typeT=Uppercase<'hello'>;// 'HELLO'typeT2=Uppercase<'foo'|'bar'>;// 'FOO' | 'BAR'typeT3<Sextendsstring>=Uppercase<`aB${S}`>;typeT4=T3<'xYz'>;// 'ABXYZ'typeT5=Uppercase<string>;// stringtypeT6=Uppercase<any>;// anytypeT7=Uppercase<never>;// nevertypeT8=Uppercase<42>;// Error, type 'number' does not satisfy the constraint 'string'

  • Lowercase<S extends string> - Transforms every character in a string into lowercase.

    Example 
    typeT=Lowercase<'HELLO'>;// 'hello'typeT2=Lowercase<'FOO'|'BAR'>;// 'foo' | 'bar'typeT3<Sextendsstring>=Lowercase<`aB${S}`>;typeT4=T3<'xYz'>;// 'abxyz'typeT5=Lowercase<string>;// stringtypeT6=Lowercase<any>;// anytypeT7=Lowercase<never>;// nevertypeT8=Lowercase<42>;// Error, type 'number' does not satisfy the constraint 'string'

  • Capitalize<S extends string> - Transforms the first character in a string into uppercase.

    Example 
    typeT=Capitalize<'hello'>;// 'Hello'typeT2=Capitalize<'foo'|'bar'>;// 'Foo' | 'Bar'typeT3<Sextendsstring>=Capitalize<`aB${S}`>;typeT4=T3<'xYz'>;// 'ABxYz'typeT5=Capitalize<string>;// stringtypeT6=Capitalize<any>;// anytypeT7=Capitalize<never>;// nevertypeT8=Capitalize<42>;// Error, type 'number' does not satisfy the constraint 'string'

  • Uncapitalize<S extends string> - Transforms the first character in a string into lowercase.

    Example 
    typeT=Uncapitalize<'Hello'>;// 'hello'typeT2=Uncapitalize<'Foo'|'Bar'>;// 'foo' | 'bar'typeT3<Sextendsstring>=Uncapitalize<`AB${S}`>;typeT4=T3<'xYz'>;// 'aBxYz'typeT5=Uncapitalize<string>;// stringtypeT6=Uncapitalize<any>;// anytypeT7=Uncapitalize<never>;// nevertypeT8=Uncapitalize<42>;// Error, type 'number' does not satisfy the constraint 'string'

You can find some examples in the TypeScript docs.

Maintainers

License

SPDX-License-Identifier: (MIT OR CC0-1.0)

About

A collection of essential TypeScript types

Resources

Readme
License

Contributing

Contributing

Security policy

Security policy
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages