Turn your JavaScript with Flow type annotations into
standard JavaScript in an instant with no configuration and minimal setup.
Flow provides static type checking to JavaScript which
can both help find and detect bugs long before code is deployed and can make
code easier to read and more self-documenting. The Flow tool itself only reads
and analyzes code. Running code with Flow type annotations requires first
removing the annotations which are non-standard JavaScript. Typically this is
done via adding a plugin to your Babel configuration,
however Babel may be overkill if you're only targeting modern versions of
Node.js or just not using the modern ES2015 features that may not be in
every browser.
flow-remove-types is a faster, simpler, zero-configuration alternative with
minimal dependencies for super-fast npm install time.
Wherever you use node you can substitute flow-node and have a super fast
flow-types aware evaluator or REPL.
$ flow-node> var x: number = 42undefined> x42
Note: This package is also available under the aliasflow-node since it's
often looked for at that location due to the popularity of this script. Both
scripts are available no matter which package you install.
Use the require hook
Using the require hook allows you to automatically compile files on the fly when
requiring in node, useful during development:
// Transforms all files, not just those with a "@flow" comment.require('flow-remove-types/register')({ all: true })
Use options to define exactly which files to includes or excludes with regular
expressions. All files are included by default except those found in the
node_modules folder, which is excluded by default.
Don't use the require hook in packages distributed on NPM
As always, don't forget to use flow-remove-types to compile files before distributing
your code on npm, as using the require hook affects the whole runtime and not
just your module and may hurt the runtime performance of code that includes it.
Dead-Simple Transforms
When flow-remove-types removes Flow types, it replaces them with whitespace.
This ensures that the transformed output has exactly the same number of lines
and characters and that all character offsets remain the same. This removes the
need for sourcemaps, maintains legible output, and ensures that it is super easy
to include flow-remove-types at any point in your existing build tools.
Built atop the official Flow parser,
flow-remove-types is designed to operate on the same syntax Flow itself understands.
It also passes through other common non-standard syntax such as JSX
and experimental ECMAScript proposals that Flow supports.
Before:
import SomeClass from 'some-module'import type { SomeInterface } from 'some-module'export class MyClass<T> extends SomeClass implements SomeInterface { value: T constructor(value: T) { this.value = value } get(): T { return this.value }}
After:
import SomeClass from 'some-module'export class MyClass extends SomeClass { constructor(value ) { this.value = value } get() { return this.value }}
Pretty Transform
Rather not have the whitespace? Pass the --pretty flag to remove the whitespace.