Barrelsby

Automatic TypeScript barrels (index.ts files) for your entire code base

Utils
bencoveney/barrelsbybarrelsby

README

Barrelsby Logo


Automatically create TypeScript barrels for your entire code base.

npm version
Node.js CI
CodeQL

About Barrels


Barrels are files that rollup exports from several modules into a single convenient module
typically named index.ts. They tend to help simplify large blocks of import statements at the top
of files and help to group up related functionality.

A barrel file looks like this:

  1. ```TypeScript
  2. export * from "./DropDown";
  3. export * from "./TextBox";
  4. export * from "./CheckBox";
  5. export * from "./DateTimePicker";
  6. export * from "./Slider";
  7. ```

It can help you go from messy imports like this:

  1. ```TypeScript
  2. import {DropDown} from "./src/controls/DropDown";
  3. import {TextBox} from "./src/controls/TextBox";
  4. import {CheckBox} from "./src/controls/CheckBox";
  5. import {DateTimePicker} from "./src/controls/DateTimePicker";
  6. import {Slider} from "./src/controls/Slider";
  7. ```

...to something tidier like this:

  1. ```TypeScript
  2. import {DropDown, TextBox, CheckBox, DateTimePicker, Slider} from "./src/controls";
  3. ```

...or even this:

  1. ```TypeScript
  2. import * as Controls from "./src/controls/index";
  3. ```

More Reading


TattooCoder Blog

Barrelsby Articles


Rupesh Tiwari Blog
Medium Article

Alternatives


Barrelbot
creeate-index

Usage


To install Barrelsby:

  1. ```
  2. npm install --save-dev barrelsby
  3. ```

To run barrelsby first add a script to the package.json file:

  1. ```json
  2. {
  3.   "scripts": {
  4.     "generate-barrels": "barrelsby --delete"
  5.   }
  6. }
  7. ```

You can now generate barrels:

  1. ```
  2. npm run generate-barrels
  3. ```

Configuration Options


Barrelsby accepts a number of options to help refine how your barrels are created. These options
can be configured from the command line or using a configuration file.

-c [path] or --config [path]


Specifies the location of the barrelsby configuration file. This file must be a .json file. You
can include any of the configuration options using their long name.

-d [path...] or --directory [path...]


Specifies a list of root directories where barrels will be created from. Uses the current directory
by default.

Note: This is backwards compatible with previous versions. Existing configuration files will be
parsed correctly. The following two json files will behave identically.

  1. ```json lines
  2. {
  3.   "directory": "./src"
  4. }

  6. {
  7.   "directory": ["./src"]
  8. }
  9. ```

-D or --delete


Deletes any existing barrels encountered by barrelsby. Disabled by default.

-e [regex...] or --exclude [regex...]


Excludes any files whose paths match any of the specified regular expressions.

-E or --exportDefault


Also export the default export of the file. Currently works only with the flat mode.

  1. ```TypeScript
  2. export * from "./barrel";
  3. export { default as barrel } from "./barrel";
  4. ```

-h or --help


Displays help information on the command line arguments that barrelsby accepts.

-i [regex...] or --include [regex...]


Only include files whose paths match any of the specified regular expressions.

-l [mode] or --location [mode]


The mode that barrelsby should use to determine where which directories to create barrels in.
Defaulted to top.

- top only creates a barrel in the target directory.
- below creates a barrel in every directory just below the target directory.
- all creates a barrel in every directory below (and including) the target directory.
- replace only creates barrels in directories where one already existed.
- branch creates a barrel in every directory that contains other directories.

-L or --local


Enable this to prevent barrels including modules that exist in the same directory, rather
than recursively searching child directories.

-n [name] or --name [name]


Specifies the name to use for creating new barrels (and identifying old ones). .ts wil be
appended if not included in the name. Barrels names will be defaulted to index.ts.

-s [mode] or --structure [mode]


The structure that barrelsby should create inside the barrels. Defaulted to flat.

flat


Exports modules without any nesting.

  1. ```TypeScript
  2. export * from "./barrel";
  3. export * from "./index";
  4. export * from "./directory2/script";
  5. export * from "./directory2/directory4/deeplyNested";
  6. export * from "./directory3/program";
  7. ```

filesystem


Exports modules as a nested structure that matches the file system directories.

  1. ```TypeScript
  2. import * as barrelts from "./barrel";
  3. import * as directory2directory4deeplyNestedts from "./directory2/directory4/deeplyNested";
  4. import * as directory2scriptts from "./directory2/script";
  5. import * as directory3programts from "./directory3/program";
  6. import * as indexts from "./index";
  7. export {barrelts as barrel};
  8. export const directory2 = {
  9.   directory4: {
  10.     deeplyNested: directory2directory4deeplyNestedts,
  11.   },
  12.   script: directory2scriptts,
  13. };
  14. export const directory3 = {
  15.   program: directory3programts,
  16. };
  17. export {indexts as index};
  18. ```

-q or --singleQuotes


Use 'single quotes' in the generated barrel files instead of the default "double quotes".

-S or --noSemicolon


Omit semicolons from the end of lines in the generated barrel files.

-H or --noHeader


Omit adding a header comment to the top of the barrel file.

-v or --version


Display the barrelsby version number.

-V or --verbose


Display additional debug information.

Requirements


Requires node v6.0.0 or greater for ES6 syntax.

Contributing


See CONTRIBUTING.md