TypeScript Reference : Module Resolution

TypeScript Reference : Module Resolution

In the world of programming, modularization is a common practice adopted by developers to organize their code into separate and reusable units. TypeScript, being a superset of JavaScript, provides built-in support for modules. But when it comes to resolving and loading these modules during runtime, TypeScript follows a specific set of rules known as module resolution.

Module resolution in TypeScript is the process by which the compiler determines the locations of module imports. It involves searching for the correct file or module using a variety of strategies specified in the tsconfig.json file. These strategies include classic resolution, node resolution, and more, depending on the settings specified.

One of the key aspects of module resolution is the concept of “module paths”. Module paths are the names used to import modules in TypeScript. These paths can be relative or absolute, and the compiler uses them to locate the corresponding module files or packages. In addition to resolving modules in the local project, module resolution also allows for resolving modules from external libraries or dependencies.

Understanding module resolution in TypeScript is crucial for building scalable and maintainable projects. This TypeScript reference on module resolution covers important concepts, strategies, and best practices to help you effectively manage and resolve modules in your TypeScript projects.

Table of Contents

Types of Module Resolution

TypeScript supports two main types of module resolution: Classic and Node.

Classic Resolution

In classic resolution, modules are resolved based on the paths specified in the module option of the tsconfig.json file. The compiler will look for modules relative to the baseUrl specified in the tsconfig.json file. The paths can be configured using the paths option, which maps module names to file paths or glob patterns.

This type of resolution is suitable for projects that do not use a module bundler or a package manager. It allows you to organize your code into a file structure and specify the paths to your modules explicitly.

Node Resolution

In node resolution, modules are resolved using Node.js module resolution algorithm. This algorithm is based on how Node.js resolves modules when using the require() function.

Node resolution first looks for modules in the node_modules directory of the current file’s directory, and then proceeds to search in parent directories until it reaches the root of the file system. It also considers the main field specified in the package.json file of each module to determine the entry point.

This type of resolution is suitable for projects that use a module bundler or a package manager like npm or Yarn. It allows you to install packages from the npm registry and use them directly in your TypeScript code without the need for explicit configuration.

Choosing the Right Type

The choice between classic and node resolution depends on your project’s requirements and the tools you are using. If you are building a front-end application that uses a module bundler like webpack, you would typically use node resolution. If you are building a back-end application with Node.js, you would typically use node resolution as well. However, if you are working on a project that does not use a module bundler or a package manager, classic resolution might be more appropriate.

It’s important to note that the resolution type can be specified in the tsconfig.json file using the moduleResolution option. By default, TypeScript uses classic resolution.

Node.js Module Resolution


Node.js is a popular runtime environment for executing JavaScript code on the server-side. When working with Node.js, it is important to understand how module resolution works in order to correctly import and use modules in your projects.

Module Resolution

Module resolution in Node.js follows a similar pattern as module resolution in TypeScript. However, there are a few differences to note.

Node.js resolves modules using the following strategies:

  • Core Modules
  • File Modules
  • Directory Modules

Core Modules

Core modules are modules that are built into Node.js and provide fundamental functionality. They can be imported using the require() function without specifying a path.

For example:

const fs = require('fs');

In this example, the ‘fs’ module is a core module that provides file system-related functionality.

File Modules

File modules are modules defined in individual files. They can be imported using either a relative or an absolute path.

For example, to import a file module located in the same directory as the current file, you can use:

const myModule = require('./myModule');

In this example, the ‘./myModule’ specifies the relative path to the file module.

Directory Modules

Directory modules are modules defined within a directory. They are typically used to group related functionality into a single module.

To import a directory module, you can specify the directory path without a file name. If a ‘package.json’ file exists in the directory, Node.js will use the ‘main’ property in the ‘package.json’ file to determine which file to load.

See also:  Vue.js TypeScript : TS with Options API

const myModule = require('./myModule');

In this example, the ‘./myModule’ specifies the directory path. Node.js will look for a ‘package.json’ file in the specified directory and use the ‘main’ property to determine which file to load.


Understanding module resolution in Node.js is essential for effectively using and organizing modules in your projects. By knowing the different strategies for resolving modules, you can import and use modules correctly in your Node.js applications.

Classic Resolution Algorithm

The classic resolution algorithm is the default module resolution strategy used by TypeScript. It follows a set of rules to find and load modules, based on the specified import statements in your TypeScript code.

Resolution Process

  1. The resolution process starts when TypeScript encounters an import statement in your code.
  2. It first checks if the imported module is a built-in module like ‘fs’ or ‘path’. If so, TypeScript uses the built-in definition file associated with the module (usually found in the TypeScript installation directory) and resolves the import.
  3. If the imported module is not a built-in module, TypeScript moves on to the next step.
  4. The algorithm then looks for a declaration file with a ‘.d.ts’ extension in the same directory as the importing file. If found, TypeScript resolves the import using this declaration file.
  5. If no declaration file is found in the same directory, TypeScript looks for an ambient module declaration in a type definition file (‘.d.ts’) in the closest parent directory.
  6. If the module is not found in any of the above steps, TypeScript checks if the module is a relative or an absolute path to a file. If so, it tries to resolve the module based on the file path.
  7. If the module is still not found, TypeScript checks the ‘node_modules’ folder in the current directory and its parent directories, recursively.

Module Resolution Cache

TypeScript caches the resolution results to optimize compilation time. When the compiler resolves a module, it caches the result in memory. If the same module is encountered again during the compilation process, TypeScript retrieves the resolution result from the cache instead of re-evaluating the module resolution algorithm.

Custom Module Resolution

If the classic resolution algorithm does not meet your needs, TypeScript allows you to define custom module resolution strategies. You can configure module resolution using the ‘baseUrl’, ‘paths’, ‘rootDirs’, and other options in the ‘tsconfig.json’ file.


The classic resolution algorithm is the default module resolution strategy in TypeScript. It follows a set of rules to find and load modules, based on the specified import statements in your code. TypeScript also provides the ability to define custom module resolution strategies if needed.

Node.js-like Resolution Algorithm

In TypeScript, module resolution refers to the process of finding and loading external modules referenced in a TypeScript file. TypeScript supports different module resolution strategies, one of which is the Node.js-like resolution algorithm.

Resolution Steps

  1. The compiler starts by checking if the module name is a relative path or starts with a dot (e.g., “./module” or “../module”). If so, it resolves the module file relative to the importing file’s location.
  2. If the module name is not a relative path, the compiler checks if the module name is declared in the ambient module declaration (e.g., in a declaration file like `node.d.ts`). If found, the compiler uses the ambient module declaration’s definition to locate the module.
  3. If the module name is not found in the ambient module declarations, the compiler moves up the directory structure, looking for any “node_modules” folder and resolves the module from there. It searches each “node_modules” folder iteratively starting from the directory of the current file and going up the directory structure.
  4. If the module is not found in any “node_modules” folder, the compiler checks the global scope (known as the global module).

Order of File Extensions

When resolving modules, TypeScript tries to add file extensions to the module name in a specific order. The order is:

  1. If the module name has the file extension (e.g., `import { foo } from ‘./module.ts’;`), the compiler directly uses the provided file.
  2. If the module name has an import path, but the extension is not specified (e.g., `import { foo } from ‘./module’;`), the compiler uses the following order to try different file extensions: .ts, .tsx, .d.ts, .json.
  3. If the module name is a directory and does not have a file extension (e.g., `import { foo } from ‘./module’;`), the compiler appends the following extensions in the specific order: “/index.[ext]”, “/index.ts”, “/index.tsx”, “/index.d.ts”, “/index.json”.

Resolution Priority

Node.js-like module resolution algorithm uses a priority order to resolve modules:

  1. If a module file has the same name as a built-in node.js module (e.g., “fs” or “path”), TypeScript prioritizes the built-in module and resolves it.
  2. If a module file has the same name as a global module declaration (e.g., “jquery” or “lodash”), TypeScript prioritizes the global module declaration and resolves it.
  3. If none of the above matches, TypeScript resolves the module based on the first match it founds in the “node_modules” directories, starting from the closest one to the importing file’s directory.


The Node.js-like resolution algorithm used by TypeScript follows a set of steps to resolve external modules. It starts by checking if the module name is a relative path or declared in the ambient module declarations. If not found, it searches for the module in the “node_modules” directories and resolves it based on the given priority order. Understanding the module resolution algorithm helps ensure that TypeScript finds and loads the correct modules when building applications.

Understanding Module Resolution Paths


In TypeScript, module resolution is the process of finding and loading the imported modules in your code. When you use the import or export keywords, TypeScript looks for the specified module and resolves its path according to a predefined set of rules.

Module Resolution Paths

TypeScript provides several ways to resolve module paths. The resolution algorithm looks for modules in the following locations:

  1. Classic Resolution: Also known as Node.js resolution, this is the default approach used by TypeScript. It resolves module paths based on the node_modules directories and the main field in the package.json file.
  2. Module Mapping: Module paths can be mapped to custom locations using the paths compiler option in the tsconfig.json file. This allows you to specify alternative locations for imported modules.
  3. Base URL: The baseUrl compiler option in tsconfig.json allows you to specify a base path for module resolution. This is useful when working with a complex project structure where module files are located in different directories.
See also:  TypeScript Reference : Namespaces

Configuring Module Resolution

Configuring Module Resolution

To configure the module resolution paths, you need to update the tsconfig.json file in your TypeScript project. Here is an example:


"compilerOptions": {

"baseUrl": "./src",

"paths": {

"@app/*": ["./app/*"],

"@utils/*": ["./utils/*"]




  • The baseUrl is set to ./src, which means that all module resolution is relative to the src directory.
  • The paths configuration maps module paths starting with @app/ to the ./app/ directory and module paths starting with @utils/ to the ./utils/ directory.

With this configuration, you can import modules like:

import { Component } from '@app/component';

import { Logger } from '@utils/logger';

These module paths will be resolved to:

  • ./src/app/component.ts for @app/component
  • ./src/utils/logger.ts for @utils/logger


Understanding how module resolution paths work in TypeScript is important for creating modular and maintainable code. By configuring the module resolution paths in your tsconfig.json file, you can control how TypeScript resolves the module imports in your code.

Module Resolution for Webpack

Module Resolution for Webpack

When using TypeScript with Webpack, module resolution allows you to configure how the compiler finds and loads modules. By default, TypeScript uses its own module resolution algorithm, which is different from the one used by Webpack.

Ambient Modules

If you are using ambient modules in your TypeScript code, you need to configure Webpack to recognize and resolve them correctly. Ambient modules typically do not have an associated file and are loaded through a global variable. You can declare them using the declare keyword in TypeScript, and then configure Webpack to handle them properly.

To configure Webpack for ambient modules, you can use the externals configuration option. This option tells Webpack that a module should be treated as an external dependency and should not be bundled. Instead, it will be resolved at runtime.

Module Resolution Strategy

Webpack’s module resolution algorithm uses a combination of the Node.js resolution algorithm and its own resolution logic. It traverses through the directories defined in the resolve.modules configuration option to look for modules.

The resolve.modules option is an array of directories that Webpack should search for modules when using an import or require statement. By default, this array includes the node_modules folder, but you can add additional directories if needed.

Resolve Extensions

Webpack also uses the resolve.extensions configuration option to determine which file extensions should be considered when resolving modules. By default, it includes .js and .json.

If you are using TypeScript, you should include .tsx and .ts in the resolve.extensions array to ensure that TypeScript files are properly resolved.

Ambient Plugins

If you are using ambient plugins, such as webpack.IgnorePlugin to exclude certain modules from being bundled, you need to be aware of how it interacts with TypeScript module resolution.

When using ambient plugins, you should also configure TypeScript to ignore those files by adding them to the exclude option in the tsconfig.json file.


When using TypeScript with Webpack, it is important to configure module resolution correctly to ensure that your dependencies are resolved and loaded properly. This includes handling ambient modules and plugins, configuring the module resolution strategy, and setting up the resolve extensions.

Configuring Module Resolution


TypeScript offers a powerful module resolution system that allows you to specify how the compiler resolves module imports. By default, TypeScript uses Node.js resolution strategy, but it also supports several other module resolution strategies.

Module Resolution Strategies

TypeScript provides the following module resolution strategies:

  • Classic: This strategy is used for compatibility with older JavaScript modules. It searches for modules in a set of predefined directories.
  • Node: This strategy is used to mimic Node.js module resolution. It searches for modules in node_modules directories and uses the Node.js resolution algorithm.
  • Webpack: This strategy is used when using webpack module bundler. It searches for modules using webpack’s resolution algorithm.
  • Module directories: This strategy allows you to specify custom module directories. It searches for modules in the specified directories.

Configuring Module Resolution

You can configure module resolution in your TypeScript project by using the tsconfig.json file. Here’s an example:


"compilerOptions": {

"moduleResolution": "node"



In this example, the module resolution is set to “node”, which means TypeScript will use the Node.js resolution strategy.

You can also specify the module resolution directly in the command line when invoking the TypeScript compiler. Here’s an example:

tsc --moduleResolution node app.ts

In this example, the module resolution is set to “node” using the --moduleResolution flag.


Configuring module resolution in TypeScript allows you to control how the compiler resolves module imports. You can choose from various module resolution strategies depending on your project requirements. Whether you configure it in the tsconfig.json file or directly in the command line, module resolution offers flexibility and compatibility with different module systems.

Module Resolution in Visual Studio Code

Visual Studio Code is a powerful code editor that provides excellent support for TypeScript development. It includes built-in features for module resolution, which helps developers organize and manage their codebase.

Module Resolution Basics

Module resolution is the process by which the TypeScript compiler determines the location of imported modules. There are different ways to configure module resolution in TypeScript, but in Visual Studio Code, the default setting is known as “Classic”.

When using “Classic” module resolution, Visual Studio Code looks for modules relative to the importing file. It searches for modules in the same directory as the importing file, as well as in the node_modules folder.

Configuring Module Resolution

Visual Studio Code allows developers to configure module resolution settings through the tsconfig.json file. This file specifies the root directory and other compiler options for a TypeScript project.

By default, the tsconfig.json file uses the “Classic” module resolution setting. To change the module resolution strategy, developers can specify the “moduleResolution” option in the compilerOptions section of the tsconfig.json file.

For example, to use the “Node” module resolution strategy, which resolves modules based on Node.js module resolution, you can set the “moduleResolution” option to “node”.

Advanced Module Resolution Features

Visual Studio Code also provides advanced features for module resolution. For example, if you have multiple files with the same name but in different folders, Visual Studio Code can intelligently resolve the correct module based on the import statement.

Additionally, Visual Studio Code supports path mapping, which allows you to map import paths to different locations in your codebase. This can be useful when you want to abstract the actual file structure and provide a clear and concise way to import modules.


Module resolution is an important aspect of TypeScript development, and Visual Studio Code provides excellent support for managing module dependencies. By understanding and configuring module resolution settings, developers can ensure that their codebase is organized and maintainable.

Best Practices for Module Resolution

1. Use relative import paths

When importing modules within your project, it is best to use relative import paths instead of absolute paths. Relative import paths are shorter and more concise, making it easier to navigate and understand the project structure.

For example, instead of using:

import { SomeModule } from 'src/app/modules/some-module';

You can use:

import { SomeModule } from '../somemodule';

By using relative import paths, you can prevent issues that may arise when the project structure changes or when the project is inherited by other developers.

2. Use explicit file extensions

To avoid confusion, it is recommended to always include explicit file extensions when importing modules. This makes it clear what type of module is being imported and helps prevent any ambiguity in the resolution process.

For example, instead of using:

import { SomeModule } from './some-module';

You can use:

import { SomeModule } from './some-module.js';

By using explicit file extensions, you can ensure that the module resolution process is more accurate and predictable.

3. Specify baseUrl in tsconfig.json

In your project’s tsconfig.json file, it is recommended to specify the baseUrl property to define the base path for resolving modules.

For example:


"compilerOptions": {

"baseUrl": "./src",

"module": "commonjs",





By setting the baseUrl, you can simplify module imports by allowing TypeScript to automatically resolve paths relative to the specified base path.

4. Use module aliases

For large projects with complex folder structures, it can be beneficial to set up module aliases to create shorter and more intuitive import paths.

For example, instead of using:

import { SomeModule } from '../../../modules/some-module';

You can use:

import { SomeModule } from '@modules/some-module';

By defining module aliases in your project’s tsconfig.json file, you can improve code readability and make it easier to navigate and understand the project structure.

5. Regularly update dependencies

It is important to regularly update your project’s dependencies, including the TypeScript compiler, to take advantage of any bug fixes, performance optimizations, and new features related to module resolution.

By staying up-to-date with the latest versions of TypeScript and related dependencies, you can ensure that your project benefits from the latest improvements in module resolution.

6. Use a consistent and well-defined project structure

Having a consistent and well-defined project structure can greatly simplify the module resolution process. By organizing your project’s files and folders in a logical and consistent manner, it becomes easier to locate and import modules.

It is recommended to follow established best practices and project structure conventions, such as grouping related modules in dedicated folders and using clear and concise module names.

By adhering to a consistent project structure, you can reduce the complexity of module resolution and improve the maintainability of your codebase.

7. Avoid circular dependencies

When working with modules, it is important to avoid circular dependencies whenever possible. Circular dependencies can create issues during the module resolution process, leading to runtime errors or unexpected behavior.

If you encounter a circular dependency, it is recommended to refactor your code to remove the circular reference or rethink the design to reduce interdependencies.

By avoiding circular dependencies, you can prevent potential issues in the module resolution process and ensure the stability and reliability of your codebase.


What is module resolution in TypeScript?

Module resolution in TypeScript refers to the algorithm used by the compiler to determine the location of imported modules in the code. It helps the compiler find the correct file that contains the requested module.

How does TypeScript resolve module imports?

TypeScript resolves module imports by following a set of rules defined by the compiler. It looks for modules in specific locations and uses various strategies to determine the correct file. It can resolve modules using absolute and relative paths, as well as using node_modules or ambient modules.

What happens if the TypeScript compiler cannot resolve a module import?

If the TypeScript compiler cannot resolve a module import, it will throw a compilation error. The error message will indicate that the module could not be found. In this case, you may need to check your module resolution settings or verify that the module is installed in the correct location.

Can I change the default module resolution behavior in TypeScript?

Yes, you can change the default module resolution behavior in TypeScript by modifying the tsconfig.json file. You can specify different module resolution options, such as “classic” or “node”, to override the default behavior. This can be useful if you are working with different module systems or have specific requirements for module resolution.