jstyper
Turns your JavaScript to TypeScript / Flow (adds types, converts requires to imports, etc); ALPHA QUALITY
JsTyper adds {TypeScript, Flow, Closure} types to JavaScript programs using iterative type propagation and the TypeScript Language Services.
Run it
- Interactive online demo
npm i -g jstyper
thenjstyper input.js
- Noteworthy flags:
-o <outputDir>
(or--outputDir=<outputDir>
): where files should be generated--declarations
: only generate interface files (*.d.ts
)
- Noteworthy flags:
Features
- Assumes your JS code is correct, and propagates inferred types globally (across different files):
- From call sites: if you call
f(1)
, it will assumefunction f
can take anumber
argument. If you callf()
somewhere else, it will assume that argument is optional. - From function bodies: in
function f(x) { return x * 2 }
it's obviousx
must be anumber
. Similar constraints appear when you test arguments for nullity or for equality with other values, etc. - From call shapes: from
x.y() * x.n;
it infersx: {y(): void, readonly n: number}
- From call sites: if you call
- Rewrites
require
calls to ES2016 (ES6) imports. - Rewrites
module.exports
to ES2016 (ES6) exports. - Supports writing declarations (
*.d.ts
) files only with the--declarations
flag. - Writes a summary of imported / required module interfaces in
dependencies.d.ts
(e.g. if youvar foo = require('foo'); foo.bar()
it will inferdeclare module "foo" { export function bar(): void }
) - Rewrites
var
tolet
Example
example.js:
{ return x * 2;} { if oaddValue return + ovalue; return oname == 'default' ? x : 'y';} { var v = ; return v;}
example.ts:
: number { return x * 2;} { if oaddValue return + ovalue; return oname == 'default' ? x : 'y';} { let v = ; return v;}
TODO
- Bundle & support DOM & ES2015+ libs
- Support
var foo = require('./bar').foo
pattern - Support
var Foo = function() {}; Foo.prototype.bar = ...
(create companioninterface Foo { bar... }
) - Parse and output flow comment / flow types (+ compare with Flow)
- Lint mode
- Split large tests into smaller specs
- Better propagate contextual types in expressions (e.g. in
(a && b && c
,a ? b : c
) - Use type constraints instead of types to allow local inference passes
- Support merging of symbols added after structural members
{x: number} | Foo
- Handle index operators
- Infer
x: Promise<T>
from(await x): T
- WebDriver test for demo
- Support literal types
- Use
const
when appropriate invar
rewrite. - Proper cli args parsing +
--help
- Better
new F()
class creation inference
Hack it
- Clone this repo
- Run
npm i
- Debug the demo
npm start
(will auto-reload and auto-run tests after any changes made to the TypeScript sources) - More options: take a look at package.json's script entries