flow-to-typescript

by bcherny

Convert Flow-annotated files to TypeScript

425 Stars 45 Forks Last release: Not found MIT License 46 Commits 0 Releases

Available items

No Items, yet!

The developer of this repository has not created any items for sale yet. Need a bug fixed? Help with integration? A different license? Create a request here:

Flow-to-TypeScript Build Status npm mit

Compile Flow files to TypeScript

In Pre-Alpha - contributions welcome.

Installation

# Using Yarn:
yarn add flow-to-typescript

Or, using NPM:

npm install flow-to-typescript --save

Usage

CLI

# Install globally
yarn global add flow-to-typescript

Compile a file (all of these are equivalent)

flow2ts my/file.js.flow flow2ts my/file.js.flow my/file.ts flow2ts my/file.js.flow > my/file.ts flow2ts -i my/file.js.flow -o my/file.ts flow2ts --input my/file.js.flow --output my/file.ts

Programmatic

import { compile } from 'flow-to-typescript'
import { readFileSync, writeFileSync } from 'fs'

let path = 'path/to/file.js.flow' let file = readFileSync(path, 'utf-8')

compile(file, path).then(ts => writeFileSync('path/to/file.ts', ts) )

TypeScript vs. Flow

Features

| Done? | | Flow | TypeScript | |-------|-------------|-----------------------------------------|------------| | ✅ | Maybe |

?type
(NullableTypeAnnotation) |
type \| null \| undefined
| | ✅ | Null |
null
|
null
| | ✅ | Undefined |
typeof undefined
|
undefined
| | ✅ | Mixed |
mixed
|
unknown
| | ✅ | Void |
void
|
void
| | ✅ | Functions |
(A, B) => C
|
(a: A, b: B) => C
| | ⚔ | Predicates (0) |
(a: A, b: B) => %checks
|
(a: A, b: B) => C
| | ⚔ | Predicates (1) |
(a: A, b: B) => C %checks
|
(a: A, b: B) => C
| | ✅ | Exact types |
{\| a: A \|}
|
{ a: A }
| | ✅ | Indexers |
{ [A]: B }
|
{ [a: A]: B }
| | ✅ | Opaque types |
opaque type A = B
|
type A = B
(not expressible) | | ✅ | Variance |
interface A { +b: B, -c: C }
|
interface A { readonly b: B, c: C }
| | ✅ | Bounds |
                           | 
| | ✅ | Casting |
(a: A)
|
(a as A)
| | ✅ | Import default type |
import type A from './b'
|
import A from './b'
| | ✅ | Import named type |
import type { A } from './b'
|
import { A } from './b'
|

Utilities

| Done? | | Flow | TypeScript | |-------|-------------|-----------------------------------------|------------| | | Keys |

$Keys
|
keyof A
| | | Values |
$Values
|
A[keyof A]
| | ✅ | ReadOnly |
$ReadOnly
|
Readonly
| | ✅ | Exact |
$Exact
|
A
| | | Difference |
$Diff
| TODO
|
|       | Rest        |
$Rest
|
Exclude
|
|       | Property type |
$PropertyType
|
T[k]
|
|       | Element type |
$ElementType
|
T[k]
|
|       | Dependent type |
$ObjMap
| TODO |
|       | Mapped tuple |
$TupleMap
| TODO |
|       | Return type |
$Call
|
ReturnType
|
|       | Class       |
Class
|
typeof A
|
|       | Supertype   |
$Supertype
|
any
(warn - vote for https://github.com/Microsoft/TypeScript/issues/14520) |
|       | Subtype     |
$Subtype
|
B extends A
|
|       | Existential type |
*
|
any` (warn - vote for https://github.com/Microsoft/TypeScript/issues/14466) |

✅ Done

⚔ Babylon doesn't support it (yet)

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.