Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/weiran-zsd/dts-cli

Zero-config CLI for TypeScript package development
https://github.com/weiran-zsd/dts-cli

babel react rollup tsdx typescript

Last synced: 2 months ago
JSON representation

Zero-config CLI for TypeScript package development

Awesome Lists containing this project

README

        

[![NPM version](https://img.shields.io/npm/v/dts-cli.svg?style=flat)](https://npmjs.org/package/dts-cli)
[![Downloads/month](https://img.shields.io/npm/dm/dts-cli.svg)](http://www.npmtrends.com/dts-cli)
[![Conventional Commits](https://img.shields.io/badge/Conventional%20Commits-1.0.0-yellow.svg)](https://conventionalcommits.org)

> a fork of the official tsdx.

```bash
$ npm install dts-cli -D # for npm users
$ yarn add dts-cli -D # for yarn users
$ pnpm install dts-cli -D # for pnpm users
```

Despite all the recent hype, setting up a new TypeScript (x React) library can be tough. Between [Rollup](https://github.com/rollup/rollup), [Jest](https://github.com/facebook/jest), `tsconfig`, [Yarn resolutions](https://yarnpkg.com/en/docs/selective-version-resolutions), ESLint, and getting VSCode to play nicely....there is just a whole lot of stuff to do (and things to screw up). DTS is a zero-config CLI that helps you develop, test, and publish modern TypeScript packages with ease--so you can focus on your awesome new library and not waste another afternoon on the configuration.

- [Features](#features)
- [Quick Start](#quick-start)
- [`npm start` or `yarn start`](#npm-start-or-yarn-start)
- [`npm run build` or `yarn build`](#npm-run-build-or-yarn-build)
- [`npm test` or `yarn test`](#npm-test-or-yarn-test)
- [`npm run lint` or `yarn lint`](#npm-run-lint-or-yarn-lint)
- [`prepare` script](#prepare-script)
- [Setting up VSCode](#setting-up-vscode)
- [Optimizations](#optimizations)
- [Development-only Expressions + Treeshaking](#development-only-expressions--treeshaking)
- [Rollup Treeshaking](#rollup-treeshaking)
- [Advanced `babel-plugin-dev-expressions`](#advanced-babel-plugin-dev-expressions)
- [`__DEV__`](#__dev__)
- [`invariant`](#invariant)
- [`warning`](#warning)
- [Using lodash](#using-lodash)
- [Error extraction](#error-extraction)
- [Types rollup](#types-rollup)
- [Customization](#customization)
- [Rollup](#rollup)
- [Example: Adding Postcss](#example-adding-postcss)
- [Babel](#babel)
- [Jest](#jest)
- [ESLint](#eslint)
- [`patch-package`](#patch-package)
- [Inspiration](#inspiration)
- [Comparison with Microbundle](#comparison-with-microbundle)
- [API Reference](#api-reference)
- [`dts watch`](#dts-watch)
- [`dts build`](#dts-build)
- [`dts test`](#dts-test)
- [`dts lint`](#dts-lint)
- [`dts create`](#dts-create)
- [Multiple Entry Files](#multiple-entry-files)
- [Contributing](#contributing)
- [Author](#author)
- [License](#license)
- [Contributors ✨](#contributors-)

## Features

DTS comes with the "battery-pack included" and is part of a complete TypeScript breakfast:

- Bundles your code with [Rollup](https://github.com/rollup/rollup) and outputs multiple module formats (CJS & ESM by default, and also UMD if you want) plus development and production builds
- Comes with treeshaking, ready-to-rock lodash optimizations, and minification/compression
- Live reload / watch-mode
- Works with React
- Human readable error messages (and in VSCode-friendly format)
- Bundle size snapshots
- Opt-in to extract `invariant` error codes
- Jest test runner setup with sensible defaults via `dts test`
- ESLint with Prettier setup with sensible defaults via `dts lint`
- Zero-config, single dependency
- Escape hatches for customization via `.babelrc.js`, `jest.config.js`, `.eslintrc.js`, and `dts.config.js`/`dts.config.ts`

## Quick Start

```bash
npx dts-cli create mylib
cd mylib
yarn start
```

That's it. You don't need to worry about setting up TypeScript or Rollup or Jest or other plumbing. Just start editing `src/index.ts` and go!

Below is a list of commands you will probably find useful:

### `npm start` or `yarn start`

Runs the project in development/watch mode. Your project will be rebuilt upon changes. DTS has a special logger for your convenience. Error messages are pretty printed and formatted for compatibility VS Code's Problems tab.

Your library will be rebuilt if you make edits.

### `npm run build` or `yarn build`

Bundles the package to the `dist` folder.
The package is optimized and bundled with Rollup into multiple formats (CommonJS, UMD, and ES Module).

### `npm test` or `yarn test`

Runs your tests using Jest.

### `npm run lint` or `yarn lint`

Runs Eslint with Prettier on .ts and .tsx files.
If you want to customize eslint you can add an `eslint` block to your package.json, or you can run `yarn lint --write-file` and edit the generated `.eslintrc.js` file.

### `prepare` script

Bundles and packages to the `dist` folder.
Runs automatically when you run either `npm publish` or `yarn publish`. The `prepare` script will run the equivalent of `npm run build` or `yarn build`. It will also be run if your module is installed as a git dependency (ie: `"mymodule": "github:myuser/mymodule#some-branch"`) so it can be depended on without checking the transpiled code into git.

## Setting up VSCode

By default the eslint VSCode extension won't work, since it can't find the configuration file needed in order to start the eslint server. Run `npm run lint -- --write-file` in order to write the config file in the correct location.

## Optimizations

Aside from just bundling your module into different formats, DTS comes with some optimizations for your convenience. They yield objectively better code and smaller bundle sizes.

After DTS compiles your code with TypeScript, it processes your code with 3 Babel plugins:

- [`babel-plugin-annotate-pure-calls`](https://github.com/Andarist/babel-plugin-annotate-pure-calls): Injects for `#__PURE` annotations to enable treeshaking
- [`babel-plugin-dev-expressions`](https://github.com/4Catalyzer/babel-plugin-dev-expression): A mirror of Facebook's dev-expression Babel plugin. It reduces or eliminates development checks from production code
- [`babel-plugin-rename-import`](https://github.com/laat/babel-plugin-transform-rename-import): Used to rewrite any `lodash` imports

### Development-only Expressions + Treeshaking

`babel-plugin-annotate-pure-calls` + `babel-plugin-dev-expressions` work together to fully eliminate dead code (aka treeshake) development checks from your production code. Let's look at an example to see how it works.

Imagine our source code is just this:

```tsx
// ./src/index.ts
export const sum = (a: number, b: number) => {
if (process.env.NODE_ENV !== 'production') {
console.log('Helpful dev-only error message');
}
return a + b;
};
```

`dts build` will output an ES module file and 3 CommonJS files (dev, prod, and an entry file). If you want to specify a UMD build, you can do that as well. For brevity, let's examine the CommonJS output (comments added for emphasis):

```js
// Entry File
// ./dist/index.js
'use strict';

// This determines which build to use based on the `NODE_ENV` of your end user.
if (process.env.NODE_ENV === 'production') {
module.exports = require('./mylib.cjs.production.js');
} else {
module.exports = require('./mylib.cjs.development.js');
}
```

```js
// CommonJS Development Build
// ./dist/mylib.cjs.development.js
'use strict';

const sum = (a, b) => {
{
console.log('Helpful dev-only error message');
}

return a + b;
};

exports.sum = sum;
//# sourceMappingURL=mylib.cjs.development.js.map
```

```js
// CommonJS Production Build
// ./dist/mylib.cjs.production.js
'use strict';
exports.sum = (s, t) => s + t;
//# sourceMappingURL=test-react-tsdx.cjs.production.js.map
```

AS you can see, DTS stripped out the development check from the production code. **This allows you to safely add development-only behavior (like more useful error messages) without any production bundle size impact.**

For ESM build, it's up to end-user to build environment specific build with NODE_ENV replace (done by Webpack 4 automatically).

#### Rollup Treeshaking

DTS's rollup config [removes getters and setters on objects](https://github.com/palmerhq/tsdx/blob/1f6a1b6819bb17678aa417f0df5349bec12f59ac/src/createRollupConfig.ts#L73) so that property access has no side effects. Don't do it.

#### Advanced `babel-plugin-dev-expressions`

DTS will use `babel-plugin-dev-expressions` to make the following replacements _before_ treeshaking.

##### `__DEV__`

Replaces

```ts
if (__DEV__) {
console.log('foo');
}
```

with

```js
if (process.env.NODE_ENV !== 'production') {
console.log('foo');
}
```

**IMPORTANT:** To use `__DEV__` in TypeScript, you need to add `declare var __DEV__: boolean` somewhere in your project's type path (e.g. `./types/index.d.ts`).

```ts
// ./types/index.d.ts
declare var __DEV__: boolean;
```

> **Note:** The `dev-expression` transform does not run when `NODE_ENV` is `test`. As such, if you use `__DEV__`, you will need to define it as a global constant in your test environment.

##### `invariant`

Replaces

```js
invariant(condition, 'error message here');
```

with

```js
if (!condition) {
if ('production' !== process.env.NODE_ENV) {
invariant(false, 'error message here');
} else {
invariant(false);
}
}
```

Note: DTS doesn't supply an `invariant` function for you, you need to import one yourself. We recommend https://github.com/alexreardon/tiny-invariant.

To extract and minify `invariant` error codes in production into a static `codes.json` file, specify the `--extractErrors` flag in command line. For more details see [Error extraction docs](#error-extraction).

##### `warning`

Replaces

```js
warning(condition, 'dev warning here');
```

with

```js
if ('production' !== process.env.NODE_ENV) {
warning(condition, 'dev warning here');
}
```

Note: DTS doesn't supply a `warning` function for you, you need to import one yourself. We recommend https://github.com/alexreardon/tiny-warning.

### Using lodash

If you want to use a lodash function in your package, DTS will help you do it the _right_ way so that your library does not get fat shamed on Twitter. However, before you continue, seriously consider rolling whatever function you are about to use on your own. Anyways, here is how to do it right.

First, install `lodash` and `lodash-es` as _dependencies_

```bash
yarn add lodash lodash-es
```

Now install `@types/lodash` to your development dependencies.

```bash
yarn add @types/lodash --dev
```

Import your lodash method however you want, DTS will optimize it like so.

```tsx
// ./src/index.ts
import kebabCase from 'lodash/kebabCase';

export const KebabLogger = (msg: string) => {
console.log(kebabCase(msg));
};
```

For brevity let's look at the ES module output.

```js
import o from"lodash-es/kebabCase";const e=e=>{console.log(o(e))};export{e as KebabLogger};
//# sourceMappingURL=test-react-tsdx.esm.production.js.map
```

DTS will rewrite your `import kebabCase from 'lodash/kebabCase'` to `import o from 'lodash-es/kebabCase'`. This allows your library to be treeshakable to end consumers while allowing to you to use `@types/lodash` for free.

> Note: DTS will also transform destructured imports. For example, `import { kebabCase } from 'lodash'` would have also been transformed to `import o from "lodash-es/kebabCase".

### Error extraction

After running `--extractErrors`, you will have a `./errors/codes.json` file with all your extracted `invariant` error codes. This process scans your production code and swaps out your `invariant` error message strings for a corresponding error code (just like React!). This extraction only works if your error checking/warning is done by a function called `invariant`.

Note: We don't provide this function for you, it is up to you how you want it to behave. For example, you can use either `tiny-invariant` or `tiny-warning`, but you must then import the module as a variable called `invariant` and it should have the same type signature.

⚠️Don't forget: you will need to host the decoder somewhere. Once you have a URL, look at `./errors/ErrorProd.js` and replace the `reactjs.org` URL with yours.

> Known issue: our `transformErrorMessages` babel plugin currently doesn't have sourcemap support, so you will see "Sourcemap is likely to be incorrect" warnings. [We would love your help on this.](https://github.com/palmerhq/tsdx/issues/184)

_TODO: Simple guide to host error codes to be completed_

### Types rollup

DTS can automatically rollup TypeScript type definitions into a single `index.d.ts` file via [rollup-plugin-dts](https://github.com/Swatinem/rollup-plugin-dts) plugin. To enable types rollup, add `--rollupTypes` flag to your `build` and `watch` scripts.

```json
"build": "dts build --rollupTypes",
"start": "dts watch --rollupTypes",
```

[rollup-plugin-dts](https://github.com/Swatinem/rollup-plugin-dts) was seen to cause issues when using json and less imports. Use with caution.

## Customization

### Rollup

> **❗⚠️❗ Warning**:

> These modifications will override the default behavior and configuration of DTS. As such they can invalidate internal guarantees and assumptions. These types of changes can break internal behavior and can be very fragile against updates. Use with discretion!

DTS uses Rollup under the hood. The defaults are solid for most packages (Formik uses the defaults!). However, if you do wish to alter the rollup configuration, you can do so by creating a file called `dts.config.js` (or `dts.config.ts`) at the root of your project like so:

**dts.config.js**

```js
// Not transpiled with TypeScript or Babel, so use plain Es6/Node.js!
/**
* @type {import('dts-cli').DtsConfig}
*/
module.exports = {
// This function will run for each entry/format/env combination
rollup(config, options) {
return config; // always return a config.
},
};
```

or

```js
const defineConfig = require('dts-cli').defineConfig;

module.exports = defineConfig({
// This function will run for each entry/format/env combination
rollup: (config, options) => {
return config; // always return a config.
},
});
```

**dts.config.ts**

```typescript
import { defineConfig } from 'dts-cli';

export default defineConfig({
// This function will run for each entry/format/env combination
rollup: (config, options) => {
return config; // always return a config.
},
});
```

The `options` object contains the following:

```tsx
export interface DtsOptions {
// path to file
input: string;
// Name of package
name: string;
// JS target
target: 'node' | 'browser';
// Module format
format: 'cjs' | 'umd' | 'esm' | 'system';
// Environment
env: 'development' | 'production';
// Path to tsconfig file
tsconfig?: string;
// Is error extraction running?
extractErrors?: boolean;
// Is minifying?
minify?: boolean;
// Is this the very first rollup config (and thus should one-off metadata be extracted)?
writeMeta?: boolean;
// Only transpile, do not type check (makes compilation faster)
transpileOnly?: boolean;
}
```

#### Example: Adding Postcss

```js
const postcss = require('rollup-plugin-postcss');
const autoprefixer = require('autoprefixer');
const cssnano = require('cssnano');

module.exports = {
rollup(config, options) {
config.plugins.push(
postcss({
plugins: [
autoprefixer(),
cssnano({
preset: 'default',
}),
],
inject: false,
// only write out CSS for the first bundle (avoids pointless extra files):
extract: !!options.writeMeta,
})
);
return config;
},
};
```

### Babel

You can add your own `.babelrc` to the root of your project and DTS will **merge** it with [its own Babel transforms](./src/babelPluginTsdx.ts) (which are mostly for optimization), putting any new presets and plugins at the end of its list.

### Jest

You can add your own `jest.config.js` to the root of your project and DTS will **shallow merge** it with [its own Jest config](./src/createJestConfig.ts).

### ESLint

You can add your own `.eslintrc.js` to the root of your project and DTS will **deep merge** it with [its own ESLint config](./src/createEslintConfig.ts).

### `patch-package`

If you still need more customizations, we recommend using [`patch-package`](https://github.com/ds300/patch-package) so you don't need to fork.
Keep in mind that these types of changes may be quite fragile against version updates.

## Inspiration

DTS was originally ripped out of [Formik's](https://github.com/jaredpalmer/formik) build tooling.
DTS has several similarities to [@developit/microbundle](https://github.com/developit/microbundle), but that is because Formik's Rollup configuration and Microbundle's internals had converged around similar plugins.

### Comparison with Microbundle

Some key differences include:

- DTS includes out-of-the-box test running via Jest
- DTS includes out-of-the-box linting and formatting via ESLint and Prettier
- DTS includes a bootstrap command with a few package templates
- DTS allows for some lightweight customization
- DTS is TypeScript focused, but also supports plain JavaScript
- DTS outputs distinct development and production builds (like React does) for CJS and UMD builds. This means you can include rich error messages and other dev-friendly goodies without sacrificing final bundle size.

## API Reference

### `dts watch`

```shell
Description
Rebuilds on any change

Usage
$ dts watch [options]

Options
-i, --entry Entry module
--target Specify your target environment (default web)
--name Specify name exposed in UMD builds
--format Specify module format(s) (default cjs,esm)
--tsconfig Specify your custom tsconfig path (default /tsconfig.json)
--verbose Keep outdated console output in watch mode instead of clearing the screen
--onFirstSuccess Run a command on the first successful build
--onSuccess Run a command on a successful build
--onFailure Run a command on a failed build
--noClean Don't clean the dist folder
--transpileOnly Skip type checking
--rollupTypes Enable types rollup
-h, --help Displays this message

Examples
$ dts watch --entry src/foo.tsx
$ dts watch --target node
$ dts watch --name Foo
$ dts watch --format cjs,esm,umd
$ dts watch --tsconfig ./tsconfig.foo.json
$ dts watch --noClean
$ dts watch --onFirstSuccess "echo The first successful build!"
$ dts watch --onSuccess "echo Successful build!"
$ dts watch --onFailure "echo The build failed!"
$ dts watch --transpileOnly
```

### `dts build`

```shell
Description
Build your project once and exit

Usage
$ dts build [options]

Options
-i, --entry Entry module
--target Specify your target environment (default web)
--name Specify name exposed in UMD builds
--format Specify module format(s) (default cjs,esm)
--extractErrors Opt-in to extracting invariant error codes
--tsconfig Specify your custom tsconfig path (default /tsconfig.json)
--transpileOnly Skip type checking
--rollupTypes Enable types rollup
-h, --help Displays this message

Examples
$ dts build --entry src/foo.tsx
$ dts build --target node
$ dts build --name Foo
$ dts build --format cjs,esm,umd
$ dts build --extractErrors
$ dts build --tsconfig ./tsconfig.foo.json
$ dts build --transpileOnly
```

### `dts test`

This runs Jest, forwarding all CLI flags to it. See [https://jestjs.io](https://jestjs.io) for options. For example, if you would like to run in watch mode, you can run `dts test --watch`. So you could set up your `package.json` `scripts` like:

```json
{
"scripts": {
"test": "dts test",
"test:watch": "dts test --watch",
"test:coverage": "dts test --coverage"
}
}
```

### `dts lint`

```shell
Description
Run eslint with Prettier

Usage
$ dts lint [options]

Options
--fix Fixes fixable errors and warnings
--ignore-pattern Ignore a pattern
--max-warnings Exits with non-zero error code if number of warnings exceed this number (default Infinity)
--write-file Write the config file locally
--report-file Write JSON report to file locally
-h, --help Displays this message

Examples
$ dts lint src
$ dts lint src --fix
$ dts lint src test --ignore-pattern test/foo.ts
$ dts lint src test --max-warnings 10
$ dts lint src --write-file
$ dts lint src --report-file report.json
```

### `dts create`

```shell
Description
Create a new package with DTS

Usage
$ dts create [options]

Options
--template Specify a template. Allowed choices: [basic, react, react-with-storybook]
--husky Should husky be added to the generated project? (default true)
-h, --help Displays this message

Examples
$ dts create mypackage
$ dts create --template react mypackage
$ dts create --husky mypackage
$ dts create --no-husky mypackage
$ dts create --husky false mypackage
```

### Multiple Entry Files

You can run `dts watch` or `dts build` with multiple entry files, for example:

```shell
dts build \
--entry ./src/index.ts \
--entry ./src/foo.ts \
--entry ./src/subdir/index.ts \
--entry ./src/globdir/**/*.ts
```

When given multiple entries, dts-cli will output separate bundles for each file for each format, as well as their
declarations. Each file will be output to `dist/` with the same name it has in the `src/` directory. Entries in
subdirectories of `src/` will be mapped to equivalently named subdirectories in `dist/`.
dts-cli will also expand any globs.

## Contributing

Please see the [Contributing Guidelines](./CONTRIBUTING.md).

## Author

- [Jared Palmer](https://twitter.com/jaredpalmer)

## License

[MIT](https://oss.ninja/mit/jaredpalmer/)

## Contributors ✨

Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):



Jared Palmer

📖 🎨 👀 🔧 ⚠️ 🚧 💻

swyx

🐛 💻 📖 🎨 🤔 🚇 🚧 👀

Jason Etcovitch

🐛 ⚠️

Sam Kvale

💻 ⚠️ 🐛 📖 👀 🤔 💬

Lucas Polito

💻 📖 💬

Steven Kalt

💻

Harry Hedger

🤔 📖 💻 💬



Arthur Denner

🐛 💻 💬

Carl

🤔 📖 💻 ⚠️ 💬

Loïc Mahieu

💻 ⚠️

Sebastian Sebald

📖 💻 ⚠️

Karl Horky

📖 🤔

James George

📖

Anton Gilgur

🚧 📖 💻 🐛 💡 🤔 💬 👀 ⚠️



Kyle Holmberg

💻 💡 ⚠️ 👀 💬

Sigurd Spieckermann

🐛 💻

Kristofer Giltvedt Selbekk

💻

Tomáš Ehrlich

🐛 💻

Kyle Johnson

🐛 💻

Etienne Dldc

🐛 💻 ⚠️

Florian Knop

🐛



Gonzalo D'Elia

💻

Alec Larson

💻 👀 🤔 💬

Justin Grant

🐛 🤔 💬

Jirat Ki.

💻 ⚠️ 🐛

Nate Moore

💻 🤔

Haz

📖

Basti Buck

💻 🐛



Pablo Saez

💻 🐛

Jake Gavin

🐛 💻

Grant Forrest

💻 ⚠️ 🐛

Sébastien Lorber

💻

Kirils Ladovs

📖

Enes Tüfekçi

💻 📖

Bogdan Chadkin

👀 💬 🤔



Daniel K.

💻 📖 ⚠️ 🤔 🐛

Quentin Sommer

📖

Hyan Mandian

💻 ⚠️

Sung M. Kim

🐛 💻

John Johnson

💻 📖

Jun Tomioka

💻 ⚠️

Leonardo Dino

💻 🐛



Honza Břečka

💻 🐛

Ward Loos

💻 🤔

Brian Bugh

💻 🐛

Cody Carse

📖

Josh Biddick

💻

Jose Albizures

💻 ⚠️ 🐛

Rahel Lüthy

📖



Michael Edelman

💻 🤔

Charlike Mike Reagent

👀 💻 🤔

Frederik Wessberg

💬

Elad Ossadon

💻 ⚠️ 🐛

Kevin Kipp

💻

Matija Folnovic

💻 📖

Andrew

💻



Ryan Castner

💻 ⚠️ 🤔

Yordis Prieto

💻

NCPhillips

📖

Arnaud Barré

💻 📖

Peter W

📖

Joe Flateau

💻 📖

H.John Choi

📖



Jon Stevens

📖 🤔 🐛

greenkeeper[bot]

🚇 💻

allcontributors[bot]

🚇 📖

dependabot[bot]

🚇 🛡️ 💻

GitHub

🚇

Eugene Samonenko

⚠️ 💡 💬 🤔

Joseph Wang

🐛



Kotaro Sugawara

🐛 💻

Semesse

💻

Bojan Mihelac

💻

Dan Dascalescu

📖

Yuriy Burychka

💻

Jesse Hoyos

💻

Mike Deverell

💻



Nick Hehr

💻 📖 💡

Bnaya Peretz

🐛 💻

Andres Alvarez

💻 📖 💡

Yaroslav K.

📖

Dragoș Străinu

🤔

George Varghese M.

💻 📖 ⚠️

Reinis Ivanovs

🤔 💬



Orta Therox

💬 📖

Martijn Saly

🐛

Alex Johansson

📖

hb-seb

💻

seungdols

🐛

Béré Cyriac

🐛

Dmitriy Serdtsev

🐛



Vladislav Moiseev

💻

Felix Mosheev

🐛 📖

Ludovico Fischer

💻

Altrim Beqiri

🐛 💻 ⚠️

Tane Morgan

🐛 💻

This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!