flowest

Flowest

Converts Flow declarations to TypeScript.

It is focused to work with code specially written for Flowest, not some random Flow code.

Installation

You can install js_of_ocaml version via npm:

$ npm install -D flowest
# Or: $ npm install --global flowest

Flowest can also be compiled to native code.
You can manually build it from the source code (it should work much faster).

Usage

$ flowest <input-file> <output-file>
# Or: $ npx flowest <input-file> <output-file>

Features

It supports raw TypeScript via /*$$ ... */:

type A = string
/*$$
type B = Partial<{ a: A, b: number }>
*/
/*::
type C = 3
*/

Output:

type A = string
type B = Partial<{ a: A, b: number }>
type C = 3

flowest-remove-next-line and flowest-remove-line:

/*$$ type D = Partial<{ a: A, b: number }> */
// flowest-remove-next-line
type D = $Shape<{ a: A, b: number }>

Output:

type D = Partial<{ a: A, b: number }>

Table

• ✅ - Done
• 🚩 - Not fully correct

Status	Name	Flow	TypeScript
✅	Maybe	?T	T | null | undefined
✅	Null	null	null
✅	Mixed	mixed	unknown
✅	Void	void	void 🚩
	BigInt	type A = 2n	type A = 2n
✅	Union	`A	B
✅	Intersection	A & B & C	A & B & C
✅	Typeof	typeof T	typeof T
✅	Tuples	[T, U]	[T, U]
✅	Functions	(A, B) => C	(a: A, b: B) => C
✅	Predicates	(A, B) => C %checks	(a: A, b: B) => C 🚩
✅	Inexact types	{ a: A, ... } or { a: A }	{ a: A } 🚩
✅	Exact types	{| a: A |}	{ a: A } 🚩
✅	Existential types	*	any (not expressible) 🚩
✅	Indexers	{ [K]: T }	{ [key: K]: T }
✅	Bounds	<T: string>	<T extends string>
✅	Read-only fields	interface A { +b: B }	interface A { readonly b: B }
✅	Write-only fields	interface A { -c: C }	interface A { c: C } 🚩
	Inline interfaces	type T = interface { a: A }	-
	Spread properties	{ a: A, ...O }	-
	Internal slots	{ [[call]]: T => U }	-
	Generator	-	-
	AsyncGenerator	-	-
✅	Partial	$Rest<T, {}>	Partial<T>
	$Shape	$Shape<T>	- (not expressible)
✅	$ReadOnly	$ReadOnly<T>	Readonly<T>
✅	$ReadOnlyArray	$ReadOnlyArray<T>	ReadonlyArray<T>
✅	$Keys	$Keys<T>	keyof T
✅	$Values	$Values<T>	T[keyof T]
✅	$Exact	$Exact<T>	T 🚩
✅	Class	Class<T>	typeof T
✅	Property type	$PropertyType<O, k>	O[k]
✅	Element type	$ElementType<T, K>	T[K]
✅	Return type	$Call<F>	ReturnType<F>
	$Call	$Call<F, A1, A2, ..., Ak>	- (not expressible)
	$Rest	$Rest<O1, O2>	-
	$Diff	$Diff<O1, O2>	-
	$ObjMap	$ObjMap<{ a: A }, <X>(X) => X>	-
	$ObjMapi	$ObjMapi<{ a: A }, <I>(I) => I>	-
	$TupleMap	$TupleMap<[1, 2, 3], <X>(X) => X>	-
✅	$NonMaybeType	$NonMaybeType<T>	NonNullable<T> 🚩
	$CharSet	$CharSet<"abc">	- (not expressible)
	$Trusted	$Trusted<T>	- (not expressible)
	$Private	$Private<T>	- (not expressible)

Statements

Status	Name	Flow	TypeScript
✅	Import default type	import type T from './b'	import T from './b'
✅	Import named type	import type { T } from './b'	import { T } from './b'
✅	Export type	export type { T }	export { T }
✅	Declare export	declare export class Cl {}	export declare class Cl {}
	Declare export default	declare export default string	-
	Declare module	declare module 'm' { }	-
	Declare module exports	declare module.exports: T	-
✅	Type alias	type T = string	type T = string
✅	Declare type alias	declare type T = string	declare type T = string
✅	Interface	interface I extends A, B {}	interface I extends A, B {}
✅	Declare interface	declare interface I {}	declare interface I {}
	Opaque type	opaque type T = string	-
	Declare opaque type	declare opaque type T = string	-
✅	Declare variable	declare var a: number	declare var a: number
✅	Declare function	declare function f(string): number	declare function f(a: string): number
✅	Declare class	declare class B<T, U = D> extends A implements I1, I2 {}	the same
	mixins in declare class	declare class B mixins A {}	-

You can manually write TS code inside /*$$ ... */ for a feature that is not supported.

Supported version of Flow parser: 0.96.1