How to use downgradeES method in Testcafe

1import hammerhead from 'testcafe-hammerhead';
2import asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
3import { noop } from 'lodash';
4import loadBabelLibs from './babel/load-libs';
5import { ClientFunctionAPIError } from '../errors/runtime';
6import { RUNTIME_ERRORS } from '../errors/types';
7import formatBabelProducedCode from './babel/format-babel-produced-code';
8
9const ANONYMOUS_FN_RE                = /^function\s*\*?\s*\(/;
10const ES6_OBJ_METHOD_NAME_RE         = /^(\S+?)\s*\(/;
11const USE_STRICT_RE                  = /^('|")use strict('|");?/;
12const TRAILING_SEMICOLON_RE          = /;\s*$/;
13const REGENERATOR_FOOTPRINTS_RE      = /(_index\d+\.default|_regenerator\d+\.default|regeneratorRuntime)\.wrap\(function _callee\$\(_context\)/;
14const ASYNC_TO_GENERATOR_OUTPUT_CODE = formatBabelProducedCode(asyncToGenerator(noop).toString());
15
16
17function getBabelOptions () {
18    const { presetEnvForClientFunction, transformForOfAsArray } = loadBabelLibs();
19
20    return {
21        presets:       [{ plugins: [transformForOfAsArray] }, presetEnvForClientFunction],
22        sourceMaps:    false,
23        retainLines:   true,
24        ast:           false,
25        babelrc:       false,
26        highlightCode: false
27    };
28}
29
30function downgradeES (fnCode) {
31    const { babel } = loadBabelLibs();
32
33    const opts     = getBabelOptions();
34    const compiled = babel.transform(fnCode, opts);
35
36    return compiled.code
37        .replace(USE_STRICT_RE, '')
38        .trim();
39}
40
41function getDependenciesDefinition (dependencies) {
42    return Object
43        .keys(dependencies)
44        .reduce((code, name) => {
45            return code + `var ${name}=__dependencies$['${name}'];`;
46        }, '');
47}
48
49function makeFnCodeSuitableForParsing (fnCode) {
50    // NOTE: 'function() {}' -> '(function() {})'
51    if (ANONYMOUS_FN_RE.test(fnCode))
52        return `(${fnCode})`;
53
54    // NOTE: 'myFn () {}' -> 'function myFn() {}'
55    const match = fnCode.match(ES6_OBJ_METHOD_NAME_RE);
56
57    if (match && match[1] !== 'function')
58        return `function ${fnCode}`;
59
60    return fnCode;
61}
62
63function containsAsyncToGeneratorOutputCode (code) {
64    const formattedCode = formatBabelProducedCode(code);
65
66    return formattedCode.includes(ASYNC_TO_GENERATOR_OUTPUT_CODE);
67}
68
69export default function compileClientFunction (fnCode, dependencies, instantiationCallsiteName, compilationCallsiteName) {
70    if (containsAsyncToGeneratorOutputCode(fnCode))
71        throw new ClientFunctionAPIError(compilationCallsiteName, instantiationCallsiteName, RUNTIME_ERRORS.regeneratorInClientFunctionCode);
72
73    fnCode = makeFnCodeSuitableForParsing(fnCode);
74
75    // NOTE: we need to recompile ES6 code for the browser if we are on newer versions of Node.
76    fnCode = downgradeES(fnCode);
77    fnCode = hammerhead.processScript(fnCode, false);
78
79    // NOTE: check compiled code for regenerator injection
80    if (REGENERATOR_FOOTPRINTS_RE.test(fnCode))
81        throw new ClientFunctionAPIError(compilationCallsiteName, instantiationCallsiteName, RUNTIME_ERRORS.regeneratorInClientFunctionCode);
82
83    if (!TRAILING_SEMICOLON_RE.test(fnCode))
84        fnCode += ';';
85
86    const dependenciesDefinition = dependencies ? getDependenciesDefinition(dependencies) : '';
87
88    return `(function(){${dependenciesDefinition} return ${fnCode}})();`;
89}
90

Source: compile-client-function.js

import hammerhead from 'testcafe-hammerhead';
import asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
import { noop } from 'lodash';
import loadBabelLibs from './babel/load-libs';
import { ClientFunctionAPIError } from '../errors/runtime';
import { RUNTIME_ERRORS } from '../errors/types';
import formatBabelProducedCode from './babel/format-babel-produced-code';

const ANONYMOUS_FN_RE                = /^function\s*\*?\s*\(/;
const ES6_OBJ_METHOD_NAME_RE         = /^(\S+?)\s*\(/;
const USE_STRICT_RE                  = /^('|")use strict('|");?/;
const TRAILING_SEMICOLON_RE          = /;\s*$/;
const REGENERATOR_FOOTPRINTS_RE      = /(_index\d+\.default|_regenerator\d+\.default|regeneratorRuntime)\.wrap\(function _callee\$\(_context\)/;
const ASYNC_TO_GENERATOR_OUTPUT_CODE = formatBabelProducedCode(asyncToGenerator(noop).toString());


function getBabelOptions () {
    const { presetEnvForClientFunction, transformForOfAsArray } = loadBabelLibs();

    return {
        presets:       [{ plugins: [transformForOfAsArray] }, presetEnvForClientFunction],
        sourceMaps:    false,
        retainLines:   true,
        ast:           false,
        babelrc:       false,
        highlightCode: false
    };
}

function downgradeES (fnCode) {
    const { babel } = loadBabelLibs();

    const opts     = getBabelOptions();
    const compiled = babel.transform(fnCode, opts);

    return compiled.code
        .replace(USE_STRICT_RE, '')
        .trim();
}

function getDependenciesDefinition (dependencies) {
    return Object
        .keys(dependencies)
        .reduce((code, name) => {
            return code + `var ${name}=__dependencies$['${name}'];`;
        }, '');
}

function makeFnCodeSuitableForParsing (fnCode) {
    // NOTE: 'function() {}' -> '(function() {})'
    if (ANONYMOUS_FN_RE.test(fnCode))
        return `(${fnCode})`;

    // NOTE: 'myFn () {}' -> 'function myFn() {}'
    const match = fnCode.match(ES6_OBJ_METHOD_NAME_RE);

    if (match && match[1] !== 'function')
        return `function ${fnCode}`;

    return fnCode;
}

function containsAsyncToGeneratorOutputCode (code) {
    const formattedCode = formatBabelProducedCode(code);

    return formattedCode.includes(ASYNC_TO_GENERATOR_OUTPUT_CODE);
}

export default function compileClientFunction (fnCode, dependencies, instantiationCallsiteName, compilationCallsiteName) {
    if (containsAsyncToGeneratorOutputCode(fnCode))
        throw new ClientFunctionAPIError(compilationCallsiteName, instantiationCallsiteName, RUNTIME_ERRORS.regeneratorInClientFunctionCode);

    fnCode = makeFnCodeSuitableForParsing(fnCode);

    // NOTE: we need to recompile ES6 code for the browser if we are on newer versions of Node.
    fnCode = downgradeES(fnCode);
    fnCode = hammerhead.processScript(fnCode, false);

    // NOTE: check compiled code for regenerator injection
    if (REGENERATOR_FOOTPRINTS_RE.test(fnCode))
        throw new ClientFunctionAPIError(compilationCallsiteName, instantiationCallsiteName, RUNTIME_ERRORS.regeneratorInClientFunctionCode);

    if (!TRAILING_SEMICOLON_RE.test(fnCode))
        fnCode += ';';

    const dependenciesDefinition = dependencies ? getDependenciesDefinition(dependencies) : '';

    return `(function(){${dependenciesDefinition} return ${fnCode}})();`;
}