@goodmind/flowgen
v2.4.13
Published
Generate flowtype definition files from TypeScript
Downloads
2
Readme
Flowgen
The state of the converter
It's surprisingly robust and non-lossy as it stands right now, in big part thanks to how similar flow and typescript definition files are. Please see the output in this flow-typed PR for the state of the output.
| Supported? | Syntax | TypeScript | Flow |
|---|---|---|---|
| ✅ | Void type | void
| void
|
| ✅ | Undefined type | undefined
| void
|
| ✅ | Unknown type | unknown
| mixed
|
| ✅ | Symbol type | symbol
| Symbol
|
| | Unique symbol type | unique symbol
| Symbol
|
| ✅ | Object type | object
| {[key: string]: any}
|
| ✅ | Never type | never
| empty
|
| ✅ | Variance | interface A { readonly b: B, c: C }
| interface A { +b: B, c: C }
|
| ✅ | Functions | (a: A, b: B) => C
| (a: A, b: B) => C
|
| ✅ | Indexers | {[k: string]: string}
| {[k: string]: string}
|
| | This type | (this: X, a: A, b: B) => C
| (a: A, b: B) => C
|
| | Type guards | (a: X) => a is A
| (a: X) => boolean
|
| ✅ | Type parameter bounds | function f<A extends string>(a:A){}
| function f<A: string>(a:A){}
|
| ✅ | keyof X | keyof X
| $Keys<X>
|
| ✅ | X[keyof X] | X[keyof X]
| $ElementType<X, $Keys<X>>
|
| ✅ | Partial | Partial<X>
| $Rest<X, {}>
|
| ✅ | Readonly | Readonly<X>
| $ReadOnly<X>
|
| ✅ | ReadonlyArray | ReadonlyArray<X>
| $ReadOnlyArray<X>
|
| ✅ | ReadonlySet | ReadonlySet<X>
| $ReadOnlySet<X>
|
| ✅ | ReadonlyMap | ReadonlyMap<X, Y>
| $ReadOnlyMap<X, Y>
|
| ✅ | Record | Record<K, T>
| { [key: K]: T }
|
| | Pick | Pick<T, K>
| |
| | Exclude | Exclude<T, U>
| |
| | Extract | Extract<T, U>
| |
| ✅ | NonNullable | NonNullable<X>
| $NonMaybeType<X>
|
| ✅ | ReturnType | ReturnType<F>
| $Call<<R>((...args: any[]) => R) => R, F>
|
| | InstanceType | InstanceType<X>
| |
| | Required | Required<X>
| |
| | ThisType | ThisType<X>
| |
| ✅ | T['string'] | T['string']
| $PropertyType<T, k>
|
| ✅ | T[k] | T[k]
| $ElementType<T, k>
|
| ✅ | Mapped types | {[K in keyof Obj]: Obj[K]}
| $ObjMapi<Obj, <K>(K) => $ElementType<Obj, K>>
|
| | Conditional types | A extends B ? C : D
| any
|
| ✅ | typeof operator | typeof foo
| typeof foo
|
| ✅ | Tuple type | [number, string]
| [number, string]
|
| ✅ | Type alias | type A = string
| type A = string
|
| ✅ | type/typeof import | import A from 'module'
| import type A from 'module'
|
Usage
Install using npm i flowgen --save
import { compiler } from 'flowgen';
// To compile a d.ts file
const flowdef = compiler.compileDefinitionFile(filename);
// To compile a string
const flowdef = compiler.compileDefinitionString(str);
// To compile a typescript test file to JavaScript
// esTarget = ES5/ES6 etc
const testCase = compiler.compileTest(path, esTarget)
Recommended second step:
import { beautify } from 'flowgen';
// Make the definition human readable
const readableDef = beautify(generatedFlowdef);
CLI
Standard usage (will produce export.flow.js
):
npm i -g flowgen
flowgen lodash.d.ts
Options
-o / --output-file [outputFile]: Specifies the filename of the exported file, defaults to export.flow.js
Flags for specific cases
--flow-typed-format: Format output so it fits in the flow-typed repo
--compile-tests: Compile any sibling <filename>-tests.ts files found
--no-module-exports: Convert `export = Type` only to default export, instead of `declare module.exports: Type`
--interface-records: Convert TypeScript interfaces to Exact Objects
--no-jsdoc: Ignore TypeScript JSDoc
--add-flow-header: Add `// @flow` to generated files. Should be used for libs.
The difficult parts
Namespaces
Namespaces have been a big headache. What it does right now is that it splits any namespace out into prefixed global scope declarations instead. It works OK, but its not pretty and there's some drawbacks to it.
External library imports
Definitions in TS and flow are often quite different, and imported types from other libraries don't usually have
a one-to-one mapping. Common cases are React.ReactElement
, React.CSSProps
etc.
This might require manual processing, or we add a set of hardcoded mutations that handle common cases.
Odd TS conventions
Lodash has been one of the reference libraries i've worked with when creating the converter. The definition is mostly just a series of interfaces with the same name being re-declared over and over again for each function, which doesn't translate to flow at all. There's multiple ways of solving this but I don't have a great solution for it in place yet.
Contributing
All help is appreciated. Please tweet at me if you want some help getting started, or just want to discuss ideas on how to solve the trickier parts.
Distribution
git pull origin master
yarn compile
- Change the version in
package.json
git add .
- `git commit -m "New release"
npm publish
git push