Usage of the TypeScript compiler argument 'skipLibCheck'

Question

I've been researching around for a further explanation into the skipLibCheck TypeScript compiler argument to determine the safety of having this set to true. The most in-depth explanation I found is the following:

New --skipLibCheck TypeScript 2.0 adds a new --skipLibCheck compiler option that causes type checking of declaration files (files with extension .d.ts) to be skipped. When a program includes large declaration files, the compiler spends a lot of time type checking declarations that are already known to not contain errors, and compile times may be significantly shortened by skipping declaration file type checks.

Since declarations in one file can affect type checking in other files, some errors may not be detected when --skipLibCheck is specified. For example, if a non-declaration file augments a type declared in a declaration file, errors may result that are only reported when the declaration file is checked. However, in practice such situations are rare.

I understand that you obviously get a performance benefit from the compiler not having to type check files which are considered not to contain errors but I've seen this flag being used to get around errors being emitted from the compiler in relation to the declaration files having problems.

Surely using this flag to get around this decreases the integrity of the typing of your application?

Solution

To paraphrase the question tersely:

Surely [enabling skipLibCheck] decreases the integrity of the typing of your application?

I would agree that yes, it does. However, if the alternative is an application that does not compile, then it becomes a handy flag.

While Typescript itself is fairly mature, the typescript community is still relatively young. There are type definitions available for tons of libraries, and even some native typescript libraries, but they can be incompatible with one another for a variety of reasons.

You may import a library whose typing is built with a less-strict tsconfig than you would like--which your compiler could complain about when you try to use it.

You could find two libraries define the same types, but incompatibly. I've imported some libraries that supplied their own typings for a Polyfill of Buffer, and my whole application would fail to compile because of their incompatibility.

Enabling --skipLibCheck can help work around these issues. Turning it on will prevent Typescript from type-checking the entire imported libraries. Instead, Typescript will only type-check the code you use against these types. This means that as long as you aren't using the incompatible parts of imported libraries, they'll compile just fine.

tl;dr, Yes, --skipLibCheck degrades type checking, and ideally we wouldn't use it. But not every library provides perfect types yet, so skipping it can be nice.

Comments

[wojtow]

Given that --skipLibCheck speeds things up, it might make sense to use it for your everyday, dozens-of-times-a-day development compiles, but then occasionally use without (especially when initially incorporating new libraries) to assure yourself that everything passes the full type checking in the event that something gets missed by the abbreviated check. You can have the benefit of both that way.

[Wasabi]

I can also come in handy when using webworkers together with some libraries such as TFjs. See stackoverflow.com/questions/64606267/…

[Craig Hicks]

"You may import a library whose typing is built with a less-strict tsconfig than you would like" --- ideally it seems that one typescript mode could give a warning if the types intersected, and only error if they had no intersection. " You could find two libraries define the same types, but incompatibly." --- ideally typescript should be able to recognize the equivalency and allow it.

[Elanor-L]

Works like a charm for the compiling error error TS2717: Subsequent property declarations must have the same type.

[bbsimonbb]

I'm here because I'm getting a circular reference typescript error in a React module, in a freshly created React project. type alias 'ReactFragment' circularly references itself. Didn't expect to be this far into the weeds this quickly.