ts-transformer-cli

Syntax Transformer CLI for Typescript

This is a wrapper for the Typescript CLI that allows consumers to specifiy custom syntax transformers.

Transformers are specified in the tsconfig.json file and will be acquired via node require.

• When using npm packages to acquire a transformer the following naming convention is supported ts-transformer-<name>
• When a local path is pecified the package will be resolved using the $cwd.

Usage

Syntax:   tstc [options]

Examples: tstc
          tstc -p tsconfig.json

Options:

  -p, --project FILE OR DIRECTORY

  Compile the project given the path to its configuration file, 
  or to a folder with a 'tsconfig.json'.

  -v, --version

  Print the compiler's version.

The tsconfig is exactly same format as specified in typescript

Transformers

Example transformer config

// Transformer config
{
 
  // Required. Transformer name
  "mytransformer": {
 
    // Optional. Will attempt to require the path\name provided using the $cwd.
    // When omitted the cli will attempt to require('ts-transformer-<NAME>')
    "as": "./ts-transformer-mytransformer/index.js", 
 
    // Optional. Can be "before" and/or "after". "before" is the default. 
    // When "module" is specified it will replace typescript's default transform module
    // When omitted it will use "before" as the default
    "when": ["module", "before", "after"],
 
    // Config that will be given to the entry method  of the transformer
    "config": {                   
      "hello": "world"
    }
 
  }
}

The transformers config can be in a seperate file or inside the tsconfig

Example tsconfig

// as a local path specifier
{
  "compilerOptions":{...},
  "transformers": "./transformers.json"
}
 

Transformers in the tsconfig file example

//  tsconfig.json
{
  "compilerOptions":{...},
 
  "transformers": {
    // ... transformer config as above
  }
}

Example Transformer

module.exports = function (transformerConfig) {
 
  console.log("config", transformerConfig)
 
  // this is the function given to the typescript compiler
  return function (context) {
    const ts = require('typescript')
 
    function visit(node) {
      console.log("visited")
      console.log(node.text)
      return ts.visitNodes(node, visit, context)
    }
 
    return function transform(sourceFile) {
      return ts.visitNode(sourceFile, visit)
    }
  }
 
}

Example Module Transformer

// tsconfig compiler options
{
  "compilerOptions": {
    "module": "my-module-transformer"
  }
}
 
// Transformer config
{
  "my-module-transformer": {
    "when": ["module"],
    "config": {
      "hello": "world"
    }
  }
}

module.exports = function (transformerConfig, defaultTransformModule) {
 
  // this is the function given to the typescript compiler
  // defaultTransformModule is the replaced typescript function
  return function (context) {
    const ts = require('typescript')
 
    return function transform(sourceFile) {
      // write your own module
      return ts.visitNode(sourceFile, visit)
    }
  }
 
}