feat!(parse-function): simpler API, rewrite to TypeScript

[tunnckoCore]

resolves #65 + TypeScript. Really recommended to always return Result from the plugins.

The new API is the looks like this

import { parse as acornParse } from 'acorn';
import { parseFunction } from 'parse-function';

// `node` is an AST Node
function bobbyPlugin(node, result) {
  const bobby = 'bobby';

  // Really recommended to always return `Result` from the plugins.
  return { ...result, bobby };
}

function barryPlugin(node, result) {
  return { ...result, barry: 'barry barry' };
}

const result = parseFunction(bobbyPlugin.toString(), {
  parse: acornParse,
  plugins: [bobbyPlugin, barryPlugin], // supports array of plugins
  parserOptions: {},
});

console.log(result);

The console log output is

{
  name: 'bobbyPlugin',
  body: "\n  const bobby = 'bobby';\n\n  return { ...result, bobby };\n",
  args: [ 'node', 'result' ],
  params: 'node, result',
  defaults: { node: undefined, result: undefined },
  value: '(function bobbyPlugin(node, result) {\n  const ' +
    "bobby = 'bobby';\n\n  return { ...result, bobby };\n" +
    '})',
  isValid: true,
  isArrow: false,
  isAsync: false,
  isNamed: true,
  isAnonymous: false,
  isGenerator: false,
  isExpression: false,
  bobby: 'bobby',
  barry: 'barry barry'
}

TypeScript typings

type Input = string | (...args: any) => any;

interface Options {
  parse?(input: string, options?: ParserOptions): import('@babel/types').File;
  parserOptions?: ParserOptions;
  plugins?: Plugins;
}

type Plugin = (node: any, result: Result) => Result | undefined;
type Plugins = Plugin | Array<Plugin>;

interface Result {
  name: string | null;
  body: string;
  args: Array<string>;
  params: string;
  defaults: { [key: string]: string | undefined };
  value: string;
  isValid: boolean;
  isArrow: boolean;
  isAsync: boolean;
  isNamed: boolean;
  isAnonymous: boolean;
  isGenerator: boolean;
  isExpression: boolean;
}