TypeScript 2 min read

d.ts, JavaScript Library Typing, and Third-Party Types

Learn how to use TypeScript declaration files to provide type information for JavaScript libraries. This module explains .d.ts files, typing JavaScript libraries, and using third-party type definitions for safer code.

1. Understanding .d.ts Files

Declaration files (.d.ts) provide TypeScript with type information about JavaScript code without modifying the original library.

Basic Example


// mathLib.d.ts
declare function add(a: number, b: number): number;
declare const PI: number;

You can now use add and PI in TypeScript with type safety, even if the actual implementation is in plain JavaScript.

Why Declaration Files Are Important

  1. Enables type checking for JavaScript libraries.
  2. Provides IntelliSense support in IDEs.
  3. Helps prevent runtime errors by ensuring correct usage.

2. Typing JavaScript Libraries

When using a JavaScript library without types, you can create your own declaration file.

Example


// myLib.js
function greet(name) {
return `Hello, ${name}`;
}
module.exports = greet;

// myLib.d.ts
declare function greet(name: string): string;
export = greet;

Using in TypeScript


import greet = require("./myLib");
console.log(greet("Muni")); // Hello, Muni

This ensures TypeScript knows the function signature, enabling type checking.

3. Using Third-Party Type Definitions

Most popular libraries provide type definitions in the DefinitelyTyped repository (@types packages).

Installation Example


npm install lodash
npm install --save-dev @types/lodash

Using Third-Party Types


import _ from "lodash";

const numbers: number[] = [1, 2, 3];
console.log(_.shuffle(numbers)); // Type-safe usage with IntelliSense

Third-party type definitions provide:

  1. Type safety
  2. IDE auto-completion
  3. Reduced chances of runtime errors

Conclusion

Declaration files in TypeScript allow integration with JavaScript libraries safely and efficiently. Understanding .d.ts files, creating custom type definitions, and using third-party types improves type safety, development speed, and code maintainability.