@esmbly/transformer-jsdoc

Transform JavaScript files with JSDoc comments to TypeScript.

Installation

# Using Yarn:
yarn add @esmbly/transformer-jsdoc

# Or, using NPM:
npm install @esmbly/transformer-jsdoc --save

Getting Started

Check out Using the JSDoc transformer for a step-by-step guide on how to get started with @esmbly/transformer-jsdoc and the command-line interface.

Try

Try it out in the Esmbly version of WebAssembly Studio!

Usage

The @esmbly/transformer-jsdoc transforms JavaScript files with JSDoc comments to TypeScript. In order to use it, make sure you have @esmbly/cli installed .

The following Esmbly configuration will transform all JavaScript files located in the src directory and output TypeScript files to the dist directory.

// esmbly.config.js

const JSDoc = require('@esmbly/transformer-jsdoc');

module.exports = {
  input: ['./src/**/*.js'],
  transformers: [
    JSDoc.createTransformer(),
  ],
  output: [
    {
      format: '.ts',
      outDir: 'dist',
      rootDir: 'src',
    },
  ],
};

Configuration

The createTransformer() method accepts an optional configuration object (see the JSDocTransformerOptions interface). The following options are possible.

Option	Description	Type	Default
stripComments (optional)	Whether to remove remove the JSDoc comments after the transformation	boolean	false
customRules (optional)	An object containing any custom rules which should be applied (existing rules can be overridden). Check out the custom-rule example for further details.	CustomRules

Examples

• Lodash: Transforming the entire lodash library to TypeScript based on JSDoc comments.
• ms: Transforming the entire ms package to TypeScript based on JSDoc comments.
• Add: Transforming a simple JavaScript program with JSDoc comments to WebAssembly by chaining @esmbly/transformer-jsdoc and @esmbly/transformer-wasm.
• Conway's Game of Life: Transforming Conway's Game of Life (ported from the AssemblyScript project to JSDoc) to WebAssembly by chaining @esmbly/transformer-jsdoc and @esmbly/transformer-wasm.
• Insertion Sort: Transforming an insertion sort algorithm to WebAssembly by chaining @esmbly/transformer-jsdoc and @esmbly/transformer-wasm.

Supported tags

@param

Synonyms: @arg, @argument

The param tag provides the name, type and an optional description about a function parameter. To correctly be able to transform a documented function to TypeScript you are required to specify the name and type of the parameter you are documenting. The param tags also needs to be in the same order as the function parameters. Any parameter that is missing a name or type will be assumed to be any.

// input.js

/**
 * Add two numbers
 * @param {number} a
 * @param {number} b
 */
export function add(a, b) {
  return a + b;
}

// output.ts

export function add(a: number, b: number) {
  return a + b;
}

There is also support for union and rest parameters

// input.js

/**
 * @param {...number} numbers
 */
export function add(...numbers) {
  return numbers.reduce((total, n) => total + n, 0);
}

/**
 * @param {(number | string)} id
 */
export function toStringId(id) {
  return `ID${id}`;
}

// output.ts

export function add(...numbers: number[]) {
  return numbers.reduce((total, n) => total + n, 0);
}

export function toStringId(id: number | string) {
  return `ID${id}`;
}

@returns

Synonyms: @return

The returns tag specifies the return type of a function.

// input.js

/**
 * Add two numbers
 * @param {number} a
 * @param {number} b
 * @returns {number}
 */
export function add(a, b) {
  return a + b;
}

// output.ts

export function add(a: number, b: number): number {
  return a + b;
}

@type

The type tag is used to document the type of a variable.

// input.js

/**
 * @type {number}
 */
const a = add(2, 3);

// output.ts

const a: number = add(2, 3);

@constant

Synonyms: @const

The constant tag is used to document the type of a constant variable. Any documented variable that is declared using the var or let keyword will automatically be transform to a const when transforming to TypeScript.

// input.js

/**
 * @constant {string}
 */
var RED = 'FF0000';

// output.ts

const RED: string = 'FF0000';

@typeArgument

The typeArgument tag is a custom tag (not included in the JSDoc specification) that can be used to specify the the type arguments of a function call.

// input.js

/**
 * @type {number[]}
 * @typeArgument {number}
 */
const arr = toArray(1, 2, 3);

// output.ts

const arr: number[] = toArray<number>(1, 2, 3);

@declare

The declare tag is a custom tag (not included in the JSDoc specification) that can be used to specify that a variable or a function should be declared. Initializers are only allowed for constant values and can only be a string or numeric literal. If a function is tagged with @declare, the function implementation (the function body) will be removed.

// input.js

/**
 * @type {string}
 * @declare
 */
const color = 'red';

/**
 * @type {string}
 * @declare
 */
var someValue;

/**
 * @param {number} a
 * @param {number} b
 * @returns {number}
 * @declare
 */
function add(a, b) {}

// output.ts

declare const color = 'red';

declare someValue: string;

declare function add(a: number, b: number): number;

Roadmap

	JSDoc	TypeScript
Abstract	@abstract	abstract class A { }
Access	@access private	private someMethod() { }
Callback	@callback
Class methods
Enum	@enum
Interface	@interface
Implements	@implements	class A implements B { }
Namespace	@namespace MyNamespace	namespace MyNamespace { }
Nullable type	{?number}	number | null
Non-nullable type	{!number}	NonNullable<number> (strictNullChecks)
Optional parameters	@param {number} [foo]	foo?: number
Private	@private	private someProperty
Protected	@protected	protected someProperty
Public	@public	public someProperty
Read only	@readonly	readonly someProperty
Static	@static	static someMethod() { }
Typedef	@typedef
Decorator	@decorator {inline}	@inline

Contributing

All types of contributions are very much welcome. Check out our Contributing Guide for instructions on how to get started.