const typhen = require('typhen');
const result = typhen.parse('./foo.d.ts');
console.log('Parsed types: ', result.types.map(t => t.fullName));
console.log('Parsed modules: ', result.modules.map(m => m.fullName));

{
  "files": [
    "src/index.ts"
  ],
  "compilerOptions": {
    "module": "commonjs",
    "target": "ES5"
  },
  "typhen": [
    {
      "plugin": "typhen-awesome-plugin",
      "pluginOptions": { "optionName": "option value" }, // Optional. Default value is {}.
      "outDir": "output-directory",
      "files": [ "src/typings/definitions.d.ts" ]        // Optional. Default value is root's files.
      "include": [ "src/typings/include/**/*" ]          // Optional. Default value is root's include.
      "exclude": [ "src/typings/exclude/**/*" ]          // Optional. Default value is root's exclude.
    }
  ]
}

const ts = require('typescript');

module.exports = (typhen) => {
  return typhen.run({                    // typhen.run returns a Promise object of the bluebird.
    plugin: typhen.loadPlugin('typhen-awesome-plugin', {
      optionName: 'option value'
    }),
    src: 'typings/lib/definitions.d.ts', // string or string[]
    dest: 'generated',
    include: ['typings/include/**/*'],   // Optional. Default value is [].
    exclude: ['typings/exclude/**/*'],   // Optional. Default value is [].
    cwd: '../other/current',             // Optional. Default value is process.cwd().
    typingDirectory: 'typings',          // Optional. Default value is the directory name of the src.
    defaultLibFileName: 'lib.core.d.ts', // Optional. Default value is undefined, then the typhen uses the lib.d.ts or lib.es6.d.ts.
    compilerOptions: {                   // Optional. Default value is { module: ts.ScriptTarget.CommonJS, noImplicitAny: true, target: ts.ScriptTarget.ES6 }
      target: ts.ScriptTarget.ES6
    }
  }).then((files) => {
    console.log('Done!');
  }).catch((e) => {
    console.error(e);
  });
};

module.exports = (typhen, options) => {
  return typhen.createPlugin({
    pluginDirectory: __dirname,
    newLine: '\r\n',                   // Optional. Default value is '\n'.
    namespaceSeparator: '::',          // Optional. Default value is '.'.
    customPrimitiveTypes: ['integer'], // Optional. Default value is [].
    disallow: {                        // Optional. Default value is {}.
      any: true,
      tuple: true,
      unionType: true,
      intersectionType: true,
      overload: true,
      generics: true,
      anonymousObject: true,
      anonymousFunction: true,
      literalType: true,
      mappedType: true
    },
    handlebarsOptions: {               // Optional. Default value is null.
      data: options,                   // For details, see: http://handlebarsjs.com/execution.html
      helpers: {
        baz: (str) => {
          return str + '-baz';
        }
      }
    },

    rename: (symbol, name) => { // Optional. Default value is a function that returns just the name.
      if (symbol.kind === typhen.SymbolKind.Array) {
        return '[]';
      }
      return name;
    },

    generate: (generator, types, modules) => {
      generator.generateUnlessExist('templates/README.md', 'README.md');

      types.forEach((type) => {
        switch (type.kind) {
          case typhen.SymbolKind.Enum:
            generator.generate('templates/enum.hbs', 'underscore:**/*.rb', type);
            break;
          case typhen.SymbolKind.Interface:
          case typhen.SymbolKind.Class:
            generator.generate('templates/class.hbs', 'underscore:**/*.rb', type);
            break;
        }
      });
      modules.forEach((module) => {
        generator.generate('templates/module.hbs', 'underscore:**/*.rb', module);
      });
      generator.files.forEach((file) => {
        // Change a file that will be written.
      });
      return new Promise((resolve, reject) => { // If you want async processing, return a Promise object.
        // Do async processing.
      });
    }
  });
};