janakhpon / flow-to-typescript

Convert Flow-annotated files to TypeScript

Flow-to-TypeScript

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	<A: string>	<A extends string>
✅	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<A>	keyof A
	Values	$Values<A>	A[keyof A]
✅	ReadOnly	$ReadOnly<A>	Readonly<A>
✅	Exact	$Exact<A>	A
	Difference	$Diff<A, B>	TODO`
	Rest	$Rest<A, B>	Exclude
	Property type	$PropertyType<T, k>	T[k]
	Element type	$ElementType<T, K>	T[k]
	Dependent type	$ObjMap<T, F>	TODO
	Mapped tuple	$TupleMap<T, F>	TODO
	Return type	$Call<F>	ReturnType
	Class	Class<A>	typeof A
	Supertype	$Supertype<A>	any (warn - vote for microsoft/TypeScript#14520)
	Subtype	$Subtype<A>	B extends A
	Existential type	*	any (warn - vote for microsoft/TypeScript#14466)

✅ Done

⚔ Babylon doesn't support it (yet)