babel-plugin-reflow

0.5.7 • Public • Published

Reflow

Babel plugin to transpile Flow types to TypeScript with CLI wrapper.

Tests Coverage

I would love to receive feedback whether this plugin worked for you :)!

Reflow enables you to migrate a whole Flow based project to TypeScript by transpiling the Flow type annotations to equivalent TypeScript code. While this reduces the effort to move a large code base to TypeScript drastically, it is still very likely that you will face new type errors after the migration due to the differences between Flow and TypeScript. See this repository for an excellent overview of the differences and similarities of Flow and Typescript.

Why another plugin?

Of course, I am aware that other approaches exist to translate Flow to TypeScript. For instance, there is Kiikurage/babel-plugin-flow-to-typescript and Khan/flow-to-ts. When I started this project in the course of my master thesis in February 2019, the development of the first plugin seemed inactive and the second one did not exist yet. Therefore this plugin was developed to solve the given problem of the thesis in practice.

Advantages of Reflow

  • can be used either as standalone Babel plugin or through the included CLI to transpile whole code bases
  • well tested with high code coverage
  • proven to work with real React based projects (two code bases with 27 and 41 kLOC respectively were successfully migrated)
  • generates well formatted output based on Prettier with focus on placing comments at the correct position (Babel fails to do so)

Installation

yarn add --dev babel-plugin-reflow

Usage

CLI

This package includes a small CLI wrapper for the Babel plugin to recursively transpile whole directories or single files. Install the package as project dependency and run npx reflow afterwards. Alternatively you might want to install Reflow globally so you can simply type reflow:

yarn global add babel-plugin-reflow

Usage is as follows:

$ npx reflow --help

Usage: reflow [OPTION]... <FILES OR DIRECTORIES ...>

REFLOW - Flow to TypeScript converter

Options:
  -v                                Output the version number
  -d, --dry-run                     Perform a trial run printing to stdout instead of writing a file
  -e, --exclude-dirs <pattern ...>  Comma-separated list of directories to recursively exclude (default: ["node_modules"])
  -i, --include-pattern <pattern>   Set the glob pattern for input files (default: "**/*.{js,jsx}")
  -r, --replace                     Process files in-place instead of creating new TS files next to the original JS files
  -D, --replace-decorators          Replace class @decorators with wrapped function calls to avoid TypeScript errors (default: false)
  -h, --help                        Output ussage information

Examples:
  $ reflow --replace src/
  $ reflow -d -i '**/__tests__/**/*.{js,jsx}' src/
  $ reflow -exclude-patterns '**/__tests__/**/*','fixtures/*.js' src/

Programmatically

TODO

As Babel plugin

TODO

Transformations

Base types

Some Flow types are not equivalently expressible in TypeScript. See the list of unsupported Flow features below.

Type Flow TypeScript
Any type any any
Array type Array<number> Array<number>
Boolean literal type true true
Boolean type boolean boolean
Empty type empty never
Exact object type {| p: number |} { p: number }
Function type (string, {}) => number (p1: string, p2: {}) => number
Generic type annotation let v: <FlowType> let v: <TSType>
Generics type Generic<T: Super> = T type Generic<T extends Super> = T
Interface type interface I { +p: number } interface I { readonly p: number }
Intersection type type Intersection = T1 & T2 type Intersection = T1 & T2
Mixed type mixed unknown
Null literal type null null
Nullable type (Maybe) ?number number | null | undefined
Number literal type 42 42
Number type number number
Object type { [string]: number } { [key: string]: number }
Opaque type opaque type Opaque = number type Opaque = number
String literal type 'literal' 'literal'
String type string string
This type this this
Tuple type [Date, number] [Date, number]
Type alias type Type = <FlowType> type Type = <TSType>
Type casting (t: T) (t as T)
Type exports / imports import type T from './types' import T from './types
Typeof type typeof undefined undefined
Union type number | null number | null
Void type void void

Utility types

Utility Type Flow TypeScript
Call $Call<F, T...> ReturnType<F>
Class Class<T> typeof T
Difference $Diff<A, B> Omit<A, keyof B>
Element type $ElementType<T, K> T[k]
Exact $Exact<T> T
Existential type * any
Keys $Keys<T> keyof T
None maybe type $NonMaybeType<T> NonNullable<T>
Object map $ObjMap<T, F> any
Object map with key $ObjMapi<T, F> any
Property type $PropertyType<T, k> T[k]
ReadOnly $ReadOnly<T> Readonly<T>
Rest $Rest<A, B> Omit<A, Union<keyof B>>
Shape $Shape<T> Partial<T>
Tuple map $TupleMap<T, F> any
Values $Values<T> T[keyof T]
Subtype deprecated any
Supertype deprecated any

*

Declarations

Declaration Flow TypeScript
Class declare class C {} declare class C {}
Export declare export default () => string const _default: () => string; export default _default;
Function declare function f(number): any declare function f(p: number): any
Interface declare interface I {} declare interface I {}
Module declare module 'esmodule' {} declare module 'esmodule' {}
Type alias declare type T = number declare type T = number
Variable declare var v: any declare var v: any

Unsupported: CommonJS export declarations.


Unsupported Flow features / syntax

Some Flow features are not equivalently expressible in TypeScript. The Reflow CLI will output a warning with the source code location, whenever one of the following cases are encountered:

  • Constructor return types

    TypeScript intentionally doesn't support return types for constructor functions. These will be removed by Reflow.

  • Existential Type

    Flow's existential type has been deprecated and should be avoided. Still Reflow supports it and will transform it to any.

  • Function types with unnamed parameters

    In contrast to TypeScript, parameter names can be omitted in Flow. Therefore Reflow inserts parameter names automatically (p for a single parameter and p{i} for multiple ones).

    type FunctionType = ({}, Date) => string;             // Flow
    type FunctionType = (p1: {}, p2: Date) => string;    // TypeScript
    
  • Index signatures

    Flow allows any type for keys in index signatures, but Typescript only accepts string or number. Reflow will add index signatures both for string and number if a different type is specified in Flow.

    // Flow
    declare type KeyType;
    interface I = {
      [key: KeyType]: number
    }
    
    // TypeScript
    interface I = {
      [key: number]: number;
      [key: string]: number;
    }
    
  • Object type spread

    Object types can be spread into other object types in Flow. Unfortunately this syntax is not supported in TypeScript at the moment. Therefore, these properties will be ommited in output. Please fix affected object types manually.

    // Flow
    type ObjectWithSpread = {
      prop: mixed;
      ...ObjectType;
    };
    
    // TypeScript
    type ObjectWithSpread = {
      prop: unknown;
    };
    
  • Opaque Type

    Opaque types are not supported in TypeScript and are transformed to an ordinary type alias.

    opaque type T = number;  // Flow
    type T = number;         // TypeScript
    
  • Variance

    Flow's contravariance sigil - is not expressible in Typescript and will be omitted. However, TypeScript does support covariance for certain types (+ becomes readonly).

    // Flow
    interface I {
      +covariant: any;
      -contravariant: any;
    }
    
    // TypeScript
    interface I {
      readonly covariant: any;
      contravariant: any;
    }
    
  • $Call<F, T...>

    The $Call<F, T...> utility type is transformed to TypeScript's ReturnType<F>. Since this type only accepts the function type and not the function argument types, it is impossible to infer the return type of polymorphic functions. TypeScript will assume an unknown type then.

Supported syntax

This Babel plugin enables a few other Babel plugins to support various kinds of syntax:

Development

Clone this repository and install the project dependencies:

yarn install

There are various npm scripts for different tasks:

yarn build          # Create a production build
yarn dev            # Build in development mode and watch for changes
yarn format         # Format the code with Prettier
yarn lint           # Run ESLint
yarn test           # Run fixture tests
yarn test:coverage  # Run the tests with coverage report
yarn tsc            # Check the types (via TypeScript)

Package Sidebar

Install

npm i babel-plugin-reflow

Weekly Downloads

153

Version

0.5.7

License

MIT

Unpacked Size

197 kB

Total Files

153

Last publish

Collaborators

  • gruberjonathan