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:

/*$$ export type Id = unknown */
// flowest-remove-next-line
export opaque type Id = string

Output:

export type Id = unknown

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 \| C`	`A \| B \| C`
✅	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 }`	`{ a: A } & O` 🚩
	Internal slots	`{ [[call]]: T => U }`	-
✅	Partial	`$Rest<T, {}>`	`Partial<T>`
	$Shape	`$Shape<T>`	- (not expressible)
✅	$ReadOnly	`$ReadOnly<T>`	`Readonly<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)
	$Diff	`$Diff<T, U>`	`Pick<T, Exclude<keyof T, keyof U>>` 🚩
	$Rest	`$Rest<T, U>`	-
	$ObjMap	`$ObjMap<T, <X>(X) => X>`	`{ [P in keyof T]: T[P] }`
	$ObjMapi	`$ObjMapi<T, <I>(I) => I>`	`{ [I in keyof T]: I }`
	$TupleMap	`$TupleMap<T, <X>(X) => X>`	`{ [P in keyof T]: T[P] }`
✅	$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 {}`	-

Core libdefs

Status	Name	Flow	TypeScript
✅	$ReadOnlyArray	`$ReadOnlyArray<T>`	`ReadonlyArray<T>`
✅	$ReadOnlyMap	`$ReadOnlyMap<K, V>`	`ReadonlyMap<K, V>`
✅	$ReadOnlySet	`$ReadOnlySet<T>`	`ReadonlySet<T>`
	Iterator	-	-
	Iterable	-	-
	AsyncInterator	-	-
	AsyncInterable	-	-
	Generator	-	-
	AsyncGenerator	-	-

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

Supported version of Flow parser: 0.96.1

bannerets / flowest Goto Github PK

flowest's Introduction

Flowest

Installation

Usage

Features

Table

Statements

Core libdefs

flowest's People

Contributors

Stargazers

Watchers

Forkers

Recommend Projects

React

Vue.js

Typescript

TensorFlow

Django

Laravel

D3

Recommend Topics

javascript

web

server

Machine learning

Visualization

Game

Recommend Org

Facebook

Microsoft

Google

Alibaba

D3

Tencent