flowest

0.1.0 • Public • Published

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 | 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 } -
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

Dependencies (0)

    Dev Dependencies (0)

      Package Sidebar

      Install

      npm i flowest

      Weekly Downloads

      1

      Version

      0.1.0

      License

      MIT

      Unpacked Size

      3.89 MB

      Total Files

      5

      Last publish

      Collaborators

      • comonoid