ts-unused-exports

What is ts-unused-exports?

The ts-unused-exports npm package is a tool designed to help developers identify and remove unused exports in TypeScript projects. This can help in cleaning up the codebase, reducing bundle size, and improving maintainability.

What are ts-unused-exports's main functionalities?

Identify Unused Exports

This command scans the TypeScript project specified by the tsconfig.json file and lists all the exports that are not being used anywhere in the project.

npx ts-unused-exports path/to/tsconfig.json

Custom Configuration

You can customize the behavior of ts-unused-exports by specifying entry files and files to exclude in a configuration file. This allows for more precise control over which parts of the codebase are analyzed.

{
  "entryFiles": ["src/index.ts"],
  "excludeFiles": ["src/**/*.test.ts"]
}

Other packages similar to ts-unused-exports

ts-prune

ts-prune is another tool for finding unused exports in TypeScript projects. It works similarly to ts-unused-exports but offers different configuration options and may have different performance characteristics.

depcheck

depcheck is a tool that helps to find unused dependencies in a project. While it is not specific to TypeScript exports, it can be used to identify unused modules and dependencies, which can indirectly help in cleaning up unused exports.

typescript-eslint

typescript-eslint is a set of tools that allows ESLint to run on TypeScript code. It includes rules that can help identify unused variables and imports, which can be extended to help find unused exports as well.

README

ts-unused-exports

ts-unused-exports finds unused exported symbols in your Typescript project.

Installation

npm install --save-dev ts-unused-exports

or, to install globally:

npm install -g ts-unused-exports

Usage

./node_modules/.bin/ts-unused-exports path/to/tsconfig.json [file1.ts ...] [options]

or, if installed globally:

ts-unused-exports path/to/tsconfig.json [file1.ts ...] [options]

or, as a library:

import analyzeTsConfig from 'ts-unused-exports';
const result = analyzeTsConfig('path/to/tsconfig.json');
// or const result = analyzeTsConfig('path/to/tsconfig.json', ['file1.ts']);
// or const result = analyzeTsConfig('path/to/tsconfig.json', ['file1.ts', '--ignorePaths=math']);

// result : { [index:string] : ExportNameAndLocation[] }
// where the keys are file paths and the values are a structure descibing unused symbols:
// interface ExportNameAndLocation {
//   exportName: string;
//   location: LocationInFile;
// }

Options:

| Option name | Description  | Example |
|---|---|---|
| `exitWithCount` | Set the process exit code to be the count of files that have unused exports. | `--exitWithCount` |
| `ignorePaths` | Exclude files that match the given path segments. | `--ignorePaths=math;utils` |
| `showLineNumber` | Show the line number and column of the unused export. | `--showLineNumber` |

Note that if `ts-unused-exports` is called without files, the files will be read from the tsconfig's `files` or `include` key which must be present. If called with files, then those file paths should be relative to the `tsconfig.json`, just like you would specifie them in your tsconfig's `files` key.

`ts-unused-exports` also resolves path aliases specified in tsconfig's `paths` object.

Why should I use this?
----------------------

If you've ever used `tslint`'s [no-unused-variable](http://palantir.github.io/tslint/rules/no-unused-variable/) rule you already known how awesome it is. What this rule does is detect code in your modules that is not being used so that you can remove it.

For example, say that you refactored your `math.ts` module so that you no longer use `add1`:
```ts
function add1(x:number) { return x + 1; } // warning here

export default (x:number) => x + 1;

When run, tslint will complain that add1 is no longer in use.

Unfortunately, if your symbols are exported, tslint does not complain anymore. Effectively exporting a symbol anchors the symbol so that, even if nobody uses it, it will not be marked as dead code.

If you've ever found yourself mid-refactor fixing a particularly fiendish function only to realize later that nobody really uses it you know exactly what I mean.

ts-unused-exports fills this cross-module gap by complaining about exported symbols that no-one cares about.

In this sense, ts-unused-exports does not replace tslint but rather complements it by helping you detect unnecessary exports. Once those are fixed, tslint's no-unused-variable rule will kick in and tell you which code you can safely remove.

Example

There is a (very silly) example in the example/ directory.

If you want to run it you can:

git clone https://github.com/pzavolinsky/ts-unused-exports
cd ts-unused-exports
./bin/ts-unused-exports example/tsconfig.json
# or: node ./bin/ts-unused-exports example/simple/tsconfig.json
# or: node bin\ts-unused-exports example\simple\tsconfig.json

The output should be:

1 module with unused exports
math: add1

If the option --exitWithCount is used, then the exit status will equal the number of offending modules:

echo $?
# or: echo %ERRORLEVEL%
25

note: normally the exit code is 0, unless there was a problem with the arguments or the files.

If not using files or include inside your tsconfig (e.g. using webpack with ts-loader), you can explicitly specify the files to check in the command line:

./bin/ts-unused-exports example/simple/tsconfig.json app.ts math.ts

or, in a more generic way:

./bin/ts-unused-exports example/simple/tsconfig.json $(cd example/simple; find -name '*.ts')

You can use comment flags to ignore exports:

// ts-unused-exports:disable-next-line
export function add2(x:number) { return x + 2; }

Changelog

[3.0.3] - 30 Oct 2019

Changed

• (Internal) Add eslint with default rules (via typescript-eslint)
• (Internal) Fix all the linting issues