Awesome
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
(take a look at our tests)
- 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
&module.exports
to ES2015 (ES6) imports & exports - Supports writing declarations (
*.d.ts
) files only with the--declarations
flag. - Writes definitions for imported / required module interfaces (e.g. if you
var foo = require('foo'); foo.bar()
it will inferdeclare module "foo" { export function bar(): void }
) - Rewrites
var
tolet
Example
example.js:
function f(x) {
return x * 2;
}
function g(x, o) {
if (o.addValue) {
return f(x) + o.value;
}
return o.name == 'default' ? x : 'y';
}
function gg(x, y) {
var v = g(x, y);
return v;
}
example.ts:
function f(x: number): number {
return x * 2;
}
function g(x: number, o: {addValue: boolean, value: any, name: string}) {
if (o.addValue) {
return f(x) + o.value;
}
return o.name == 'default' ? x : 'y';
}
function gg(x: number, y: {addValue: boolean, value: any, name: string}) {
let v = g(x, y);
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