Function createCompiler

scripts/build.ts:28–156

* Compiles files to JavaScript. * * @param {string[]} files * @param {ts.CompilerOptions} options

(config: any, sourceDir: string)

 * @param {ts.CompilerOptions} options
 */
function createCompiler(config: any, sourceDir: string) {
    return function compile(files: string[], targetDIR: string, options: Record<string, unknown>, possibleExtensions: string[]) {
        const compilerOptions = { ...config.compilerOptions, ...options };
        const { baseUrl, paths } = compilerOptions;
        const pathVerifyResult = verifyPaths(paths);
        if (Array.isArray(pathVerifyResult)) {
            const messages = pathVerifyResult.join('\n');
            throw new Error(messages);
        }
        const { exactPaths, wildCardPaths } = rankPaths(paths);
        const host = ts.createCompilerHost(compilerOptions);
        host.writeFile = function (fileName, contents, _writeByteOrderMark, onError, _sourceFiles) {
            const isDts = fileName.endsWith('.d.ts');
            const relativeToSourceDir = relative(sourceDir, fileName);
            const subDir = join(targetDIR, dirname(relativeToSourceDir));

            mkdirSync(subDir, { recursive: true });

            let path = join(targetDIR, relativeToSourceDir);

            if (!isDts && !fileName.endsWith('.map')) {
                const astTree = parse(contents, {
                    ecmaVersion: 'latest',
                    sourceType: 'module',
                    ranges: true,
                    locations: false
                });

                switch (compilerOptions.module) {
                    case ts.ModuleKind.CommonJS: {
                        const requireStatements: any[] = [];
                        recursiveDescend(
                            astTree as any,
                            (node: any) => {
                                let flag = false;
                                if (node?.type === 'CallExpression') {
                                    const callee = node?.callee;
                                    if (callee?.type === 'Identifier' && callee?.name === 'require') {
                                        flag = true;
                                    }
                                }
                                if (flag && node?.arguments) {
                                    for (const args of node?.arguments) {
                                        if (args?.type === 'Literal') {
                                            return node;
                                        }
                                    }
                                }
                            },
                            requireStatements
                        );
                        const finalRequires = requireStatements
                            .filter((_node: any) => _node?.arguments)
                            .reduce((collector: any, _node: any) => {
                                const _requireStatements = _node.arguments.filter((args: any) => args?.type === 'Literal');
                                collector.push(..._requireStatements);
                                return collector;
                            }, []);