it('should move static apis under "Taro"', function () {
  const code = `
    import { noop } from '@tarojs/taro-h5';
    noop;
    noop();
  `

  const result = babel.transform(code, { plugins: [pluginOptions] })
  expect(result.code).toMatchSnapshot();

  const ast = result.ast as t.File
  const body = ast.program.body as [t.ImportDeclaration, t.ExpressionStatement]
  expect(t.isImportDeclaration(body[0])).toBeTruthy()
  expect(t.isExpressionStatement(body[1])).toBeTruthy()
  const defaultImport = body[0].specifiers.find(v => t.isImportDefaultSpecifier(v))
  expect(defaultImport).toBeTruthy()

  const taroName = defaultImport!.local.name
  let memberExpression = body[1].expression
  if (t.isCallExpression(body[1])) {
    memberExpression = (body[1].expression as t.CallExpression).callee
  }
  expect(memberExpression).toMatchObject(t.memberExpression(
    t.identifier(taroName),
    t.identifier('noop')
  ))
})

export default () => ({
  visitor: {
    CallExpression(nodePath: NodePath<CallExpression>, { opts, file }: { opts: { configFile: string }, file: any }) {
      if (isRequireCallExpression(nodePath)) {
        const arg = (nodePath.get("arguments") as any)[0];
        const filename = file.opts.filename;
        const targetFilename = arg.node.value;
        const webpackConfig = opts.configFile ? resolveWebpackConfig(opts.configFile) : opts;

        const loaders = webpackConfig.module
          ? ((webpackConfig.module as NewModule).rules || (webpackConfig.module as OldModule).loaders)
          : [];

        if (arg && arg.isStringLiteral() && isFileNeedToProcess(targetFilename, loaders)) {
          const finalTargetFileName = path.resolve(path.dirname(filename), targetFilename);

          const webpackResult = runWebpackSync(finalTargetFileName, webpackConfig);

          if (webpackResult.length === 0) {
            return;
          }
          const webpackResultAst = transform(webpackResult).ast;
          const pickedWebpackExpr = pickTheReturnOfWebpackResult(webpackResultAst);

          if (pickedWebpackExpr !== null) {
            nodePath.replaceWith(pickedWebpackExpr);
          }
        }
      }
    },
  },
});

 .then((code) => {
     const result = transform(code, {
         presets: ['es2015'],
         plugins: [
             'transform-decorators-legacy',
             'transform-class-properties',
             'transform-decorators',
             'transform-object-rest-spread'
         ]
     }).code;
     return result;
 })

function runValidation(source: string, expectedOutput: {}, options: Options, skipNodeCheck: boolean): void {
  let compile = options.useCS2 ? cs2Compile : cs1Compile;
  let coffeeES5 = compile(source, { bare: true }) as string;
  let decaffeinateES6 = convert(source, options).code;
  let decaffeinateES5 =
    babel.transform(decaffeinateES6, {
      presets: ['es2015'],
      plugins: ['transform-optional-chaining']
    }).code || '';

  let coffeeOutput = runCodeAndExtract(coffeeES5);
  let decaffeinateOutput = runCodeAndExtract(decaffeinateES5);
  try {
    assertDeepEqual(decaffeinateOutput, coffeeOutput, 'decaffeinate and coffee output were different.');
  } catch (err) {
    // add some additional context for debugging
    err.message = `Additional Debug:
SOURCE
${source}
********************
INPUT -> COFFEE-SCRIPT -> ES5
${coffeeES5}
********************
INPUT -> DECAFFEINATE -> ES6
${decaffeinateES6}
********************
INPUT -> DECAFFEINATE -> ES6 -> BABEL -> ES5
${decaffeinateES5}
********************
COFFEE-SCRIPT ES5 compared to DECAFFEINATE/BABEL ES5
${err.message}`;
    throw err;
  }

  // Make sure babel and V8 behave the same if we're on node >= 6.
  if (!skipNodeCheck) {
    let nodeOutput = runCodeAndExtract(decaffeinateES6);
    assertDeepEqual(decaffeinateOutput, nodeOutput, 'babel and node output were different.');
  }

  if (expectedOutput !== undefined) {
    assertDeepEqual(decaffeinateOutput, expectedOutput, 'decaffeinate and expected output were different.');
  }
}

test("should transform code with absolute configFile", (t) => {
  const babelOptions = {
    plugins: [
      [
        webpackInlineLoaders,
        {
          configFile: path.join(process.cwd(), "./fixtures/webpack.config.js"),
        },
      ],
    ],
    filename: __filename,
  };

  const codeString = transform(source, babelOptions).code;

  const exports = getExportsFromCodeString(codeString);

  t.true(_.isObject(exports));
});

export function parseCode (code: string) {
  return (transform(code, {
    parserOpts: {
      sourceType: 'module',
      plugins: [
        'classProperties',
        'jsx',
        'flow',
        'flowComment',
        'trailingFunctionCommas',
        'asyncFunctions',
        'exponentiationOperator',
        'asyncGenerators',
        'objectRestSpread',
        'decorators',
        'dynamicImport'
      ]
    }
  }) as { ast: t.File }).ast
}