xhs-mp-compiler-cli 2.0.0-beta.3 → 2.0.0

package/dist/compiler.js

@@ -1,4 +1,3 @@
-"use strict";
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -11,355 +10,356 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getProcessCompilerClass = void 0;
-/**
- * 在子进程执行编译
- */
-const child_process_1 = require("child_process");
-const path_1 = require("path");
-const stream_1 = require("stream");
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const constant_config_1 = require("./config/constant.config");
-const uuid = require('uuid');
-const isMac = process.platform === 'darwin';
-class AbstractCompiler extends stream_1.EventEmitter {
-    constructor(opts, args = {}) {
-        super();
-        this._handlerMap = {};
-        this.createSp = (passData = {}) => {
-            if (!this._cp) {
-                this._cp = this.create(Object.assign({}, passData));
-                this._cp.on('exit', code => {
-                    this._cp = null;
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "stream", "fs-extra", "./config/constant.config", "xhs-mp-workerpool"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.prepareDevPool = exports.BuildCompiler = exports.WebPackDevCompiler = exports.MPPackDevCompiler = exports.AbstractCompiler = void 0;
+    exports.getProjectCompilerClass = getProjectCompilerClass;
+    const stream_1 = require("stream");
+    const fs_extra_1 = __importDefault(require("fs-extra"));
+    const constant_config_1 = require("./config/constant.config");
+    const xhs_mp_workerpool_1 = __importDefault(require("xhs-mp-workerpool"));
+    let preparedDevPool = null;
+    class AbstractCompiler extends stream_1.EventEmitter {
+        constructor(opts, args) {
+            super();
+            // ide侧用web，cli用thread
+            this.workerType = 'process';
+            this.call = (method, data, options) => {
+                data = Object.assign(Object.assign({}, (this.compilerOpts || {})), data);
+                return this.pool.exec(method, [data], options);
+            };
+            this.compilerOpts = opts;
+            this.logger = args.logger || console;
+            this.workerType = args.workerType || 'process';
+        }
+        static prepareDevPool() {
+            preparedDevPool = AbstractCompiler.createPool('web', {
+                minWorkers: 1,
+                maxWorkers: 1 // dev最多只有一个worker，不用多个，不然无法复用首次watch初始化的compiler
+            });
+        }
+        static createPool(workerType, poolOpts = {}, processArgs = {}) {
+            let workerThreadOpts = {};
+            let forkOpts = {};
+            let workerOpts = {};
+            if (workerType === 'process') {
+                forkOpts = AbstractCompiler.createProcessOps(processArgs);
+            }
+            const pool = xhs_mp_workerpool_1.default.pool(__dirname + '/compilerImpl.js', Object.assign({ workerType: workerType, workerThreadOpts,
+                forkOpts,
+                workerOpts }, poolOpts));
+            let messageBuffers = [];
+            const handlerWorker = workerIns => {
+                workerIns.worker.on('message', payload => {
+                    if (payload === null || payload === void 0 ? void 0 : payload.customMessage) {
+                        if (!pool.emitWorkerMessage) {
+                            messageBuffers.push(payload);
+                            return;
+                        }
+                        if (messageBuffers.length) {
+                            messageBuffers.forEach(payload => {
+                                pool === null || pool === void 0 ? void 0 : pool.emitWorkerMessage(payload.event, payload.data);
+                            });
+                            messageBuffers = [];
+                        }
+                        pool === null || pool === void 0 ? void 0 : pool.emitWorkerMessage(payload.event, payload.data);
+                    }
                 });
-                this._cp.on('message', this.handleMessage);
+            };
+            pool.workers.forEach(workerIns => {
+                handlerWorker(workerIns);
+            });
+            const push = pool.workers.push.bind(pool.workers);
+            pool.workers.push = workerIns => {
+                handlerWorker(workerIns);
+                push(workerIns);
+            };
+            return pool;
+        }
+        close() {
+            if (this.pool) {
+                this.pool.exec('close');
+            }
+        }
+        kill() {
+            if (this.pool) {
+                this.pool.terminate(true);
+                this.pool = null;
+            }
+        }
+    }
+    exports.AbstractCompiler = AbstractCompiler;
+    AbstractCompiler.createProcessOps = processArgs => {
+        const { type = 'keepalive', inspectPort, nodeJsPath } = processArgs;
+        // const presistent = type === 'keepalive'
+        const execArgv = ['--expose-gc'];
+        const customNodeJs = nodeJsPath && fs_extra_1.default.existsSync(nodeJsPath);
+        if (process.env.DEV_IDE_SP) {
+            execArgv.push(`--inspect=${inspectPort}`);
+        }
+        if (customNodeJs) {
+            try {
+                fs_extra_1.default.chmodSync(nodeJsPath, 755);
             }
-            return this._cp;
+            catch (error) {
+                // do something
+            }
+        }
+        const options = {
+            stdio: 'pipe',
+            execArgv,
+            // detached: presistent,
+            windowsHide: true
         };
-        this.create = (passData = {}) => {
-            var _a, _b;
-            const { type = 'keepalive', inspectPort = this.inspectPort, maxSpaceSaze = 12288, nodeJsPath, } = this.cpArgs;
-            // const presistent = type === 'keepalive'
-            const entry = (0, path_1.join)(__dirname, './compilerCP.js');
-            const execArgv = [`--max-old-space-size=${maxSpaceSaze}`, '--expose-gc'];
-            const customNodeJs = nodeJsPath && fs_extra_1.default.existsSync(nodeJsPath);
-            if (process.env.DEV_IDE_SP) {
-                execArgv.push(`--inspect=${inspectPort}`);
+        if (customNodeJs) {
+            options.execPath = nodeJsPath;
+        }
+        return options;
+    };
+    class MPPackDevCompiler extends AbstractCompiler {
+        constructor(props, args) {
+            super(props, args);
+            this.pending = false;
+            this.pendingPkgs = {};
+            this.readyPkgs = [];
+            this.watching = false;
+            this.workerType = (args === null || args === void 0 ? void 0 : args.workerType) || 'web';
+            this.inspectPort = 9227;
+            if (preparedDevPool) {
+                this.pool = preparedDevPool;
+            }
+            else {
+                this.pool = AbstractCompiler.createPool(this.workerType, {
+                    minWorkers: 1,
+                    maxWorkers: 1 // dev最多只有一个，不用多个，不然无法复用首次watch初始化的compiler
+                });
             }
-            if (customNodeJs) {
+            this.pool.emitWorkerMessage = this.emit.bind(this);
+        }
+        reset() {
+            this.pendingPkgs = {};
+            this.readyPkgs = [];
+            this.watching = false;
+            this.pending = false;
+        }
+        doCompilePkgs(opts) {
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                const { compilePkgs = [constant_config_1.MAIN_PKG_ROOT] } = opts;
+                const todoPkgs = [];
+                let allReady = true;
+                compilePkgs.forEach(pkg => {
+                    var _a, _b;
+                    if (this.readyPkgs.includes(pkg)) {
+                        return;
+                    }
+                    allReady = false;
+                    if (this.pendingPkgs[pkg]) {
+                        (_a = this.pendingPkgs[pkg].resolve) === null || _a === void 0 ? void 0 : _a.push(resolve);
+                        (_b = this.pendingPkgs[pkg].reject) === null || _b === void 0 ? void 0 : _b.push(reject);
+                        return;
+                    }
+                    this.pendingPkgs[pkg] = {
+                        resolve: [resolve],
+                        reject: [reject]
+                    };
+                    todoPkgs.push(pkg);
+                });
+                if (allReady) {
+                    return resolve(null);
+                }
+                if (!todoPkgs.length) {
+                    return;
+                }
                 try {
-                    fs_extra_1.default.chmodSync(nodeJsPath, 755);
+                    if (!this.pending && !this.watching) {
+                        yield this.compilePkgsAndWatch(Object.assign({ compilePkgs: todoPkgs }, opts));
+                    }
+                    else {
+                        yield this.addPkgsToWatch(Object.assign({ compilePkgs }, opts));
+                    }
+                    todoPkgs.forEach(pkg => {
+                        var _a, _b;
+                        (_b = (_a = this.pendingPkgs[pkg].resolve) === null || _a === void 0 ? void 0 : _a.forEach) === null || _b === void 0 ? void 0 : _b.call(_a, fn => fn());
+                        delete this.pendingPkgs[pkg];
+                        this.readyPkgs.push(pkg);
+                    });
                 }
                 catch (error) {
-                    // do something
+                    todoPkgs.forEach(pkg => {
+                        var _a, _b;
+                        (_b = (_a = this.pendingPkgs[pkg].reject) === null || _a === void 0 ? void 0 : _a.forEach) === null || _b === void 0 ? void 0 : _b.call(_a, fn => fn());
+                        delete this.pendingPkgs[pkg];
+                    });
+                }
+            }));
+        }
+        compilePkgsAndWatch(opts) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    // if (this.pending || this.watching) {
+                    //   return
+                    // }
+                    this.pending = true;
+                    this.emit('buildStart');
+                    yield this.call('runTask', Object.assign({ scene: 'watch', action: 'dev' }, opts));
+                    this.watching = true;
+                    this.emit('buildSuccess');
+                }
+                catch (error) {
+                    this.watching = false;
+                    this.emit('buildError', { errors: [error.message] });
+                }
+                finally {
+                    this.pending = false;
                 }
-            }
-            const options = {
-                stdio: 'pipe',
-                execArgv,
-                // detached: presistent,
-                windowsHide: true,
-            };
-            if (customNodeJs) {
-                options.execPath = nodeJsPath;
-            }
-            const child = (0, child_process_1.fork)(entry, [JSON.stringify(passData)], options);
-            // if (presistent) {
-            //   child.unref()
-            // }
-            (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', msg => {
-                this.logger.debug('[compiler stdout]', msg.toString());
             });
-            (_b = child.stderr) === null || _b === void 0 ? void 0 : _b.on('data', msg => {
-                this.logger.error('[compiler stderr]', msg.toString());
+        }
+        addPkgsToWatch(opts) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const { compilePkgs = [] } = opts;
+                try {
+                    this.pending = true;
+                    this.emit('buildStart');
+                    yield this.call('activatePkgs', { compilePkgs });
+                    this.emit('buildSuccess');
+                }
+                catch (error) {
+                    this.emit('buildError', { errors: [error.message] });
+                }
+                finally {
+                    this.pending = false;
+                }
             });
-            child.on('error', err => {
-                this.logger.error('sp error:', err);
+        }
+        changeCompileOptions(options) {
+            this.call('changeCompileOptions', options);
+        }
+        makePkgsReady(opts) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield this.doCompilePkgs(opts);
             });
-            child.on('exit', code => {
-                if (code !== 0 && code !== null) {
-                    this.logger.error('sp exit:', code);
-                    this.emit('unexpectedExit', code);
+        }
+        reCompilePkgs(options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                this.readyPkgs = [];
+                this.changeCompileOptions(options);
+                if (!this.pending && !this.watching) {
+                    this.pendingPkgs = {};
                 }
+                yield this.doCompilePkgs(options);
             });
-            return child;
-        };
-        this.handleMessage = msg => {
-            var _a, _b, _c, _d;
-            let data = {};
-            try {
-                data = JSON.parse(`${msg}`);
-            }
-            catch (error) {
-                // do something
-            }
-            const { uuid, method, success, stats } = data;
-            if (method === 'callback') {
-                if (uuid && this._handlerMap[uuid]) {
-                    if (success) {
-                        (_b = (_a = this._handlerMap[uuid]).resolve) === null || _b === void 0 ? void 0 : _b.call(_a, data.data);
-                    }
-                    else {
-                        (_d = (_c = this._handlerMap[uuid]).reject) === null || _d === void 0 ? void 0 : _d.call(_c, stats);
-                    }
-                    delete this._handlerMap[uuid];
-                }
-                return;
-            }
-            if (method === 'debugger') {
-                console.log(`[debugger]:`, ...(data.data || []));
-                return;
-            }
-            this.emit(method, data);
-        };
-        this.call = (method, data) => new Promise((resolve, reject) => {
-            const id = uuid.v4();
-            const final = {
-                uuid: id,
-                method,
-                data: Object.assign(Object.assign({}, (this.compilerOpts || {})), data),
-            };
-            this._handlerMap[id] = {
-                resolve,
-                reject,
-            };
-            this.cp.send(JSON.stringify(final));
-        });
-        this.send = (method, data) => {
-            const final = {
-                method,
-                data: Object.assign(Object.assign({}, (this.compilerOpts || {})), data),
-            };
-            this.cp.send(JSON.stringify(final));
-        };
-        this.compilerOpts = opts;
-        this.cpArgs = args;
-        this.logger = args.logger || console;
-    }
-    get cp() {
-        return this.createSp();
-    }
-    close() {
-        if (this._cp) {
-            this._cp.send(JSON.stringify({ method: 'close' }));
         }
     }
-    kill() {
-        if (this._cp) {
-            this._cp.kill();
-            this._cp = null;
+    exports.MPPackDevCompiler = MPPackDevCompiler;
+    class WebPackDevCompiler extends AbstractCompiler {
+        constructor(props, args) {
+            super(props, args);
+            this.watching = false;
+            this.workerType = (args === null || args === void 0 ? void 0 : args.workerType) || 'web';
+            this.inspectPort = 9230;
+            if (preparedDevPool) {
+                this.pool = preparedDevPool;
+            }
+            else {
+                this.pool = AbstractCompiler.createPool(this.workerType, {
+                    minWorkers: 1,
+                    maxWorkers: 1 // dev最多只有一个worker，不用多个，不然无法复用首次watch初始化的compiler
+                }, args);
+            }
+            this.pool.emitWorkerMessage = this.emit.bind(this);
         }
-    }
-}
-class MPPackDevCompiler extends AbstractCompiler {
-    constructor(props, args) {
-        super(props, args);
-        this.pending = false;
-        this.pendingPkgs = {};
-        this.readyPkgs = [];
-        this.watching = false;
-        this.inspectPort = 9227;
-        this.createSp();
-    }
-    reset() {
-        this.pendingPkgs = {};
-        this.readyPkgs = [];
-        this.watching = false;
-        this.pending = false;
-    }
-    doCompilePkgs(opts) {
-        // eslint-disable-next-line no-async-promise-executor
-        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-            const { compilePkgs = [constant_config_1.MAIN_PKG_ROOT] } = opts;
-            const todoPkgs = [];
-            let allReady = true;
-            compilePkgs.forEach(pkg => {
-                var _a, _b;
-                if (this.readyPkgs.includes(pkg)) {
-                    return;
+        makePkgsReady(opts) {
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b, _c, _d;
+                if (this.watching) {
+                    return resolve(null);
                 }
-                allReady = false;
-                if (this.pendingPkgs[pkg]) {
-                    (_a = this.pendingPkgs[pkg].resolve) === null || _a === void 0 ? void 0 : _a.push(resolve);
-                    (_b = this.pendingPkgs[pkg].reject) === null || _b === void 0 ? void 0 : _b.push(reject);
+                if (this.pendingTask) {
+                    (_a = this.pendingTask.resolve) === null || _a === void 0 ? void 0 : _a.push(resolve);
+                    (_b = this.pendingTask.reject) === null || _b === void 0 ? void 0 : _b.push(reject);
                     return;
                 }
-                this.pendingPkgs[pkg] = {
+                this.pendingTask = {
                     resolve: [resolve],
-                    reject: [reject],
+                    reject: [reject]
                 };
-                todoPkgs.push(pkg);
-            });
-            if (allReady) {
-                return resolve(null);
-            }
-            if (!todoPkgs.length) {
-                return;
-            }
-            try {
-                if (!this.pending && !this.watching) {
-                    yield this.compilePkgsAndWatch(Object.assign({ compilePkgs: todoPkgs }, opts));
+                try {
+                    this.emit('buildStart');
+                    yield this.call('runTask', Object.assign({ scene: 'watch', action: 'dev' }, opts));
+                    this.watching = true;
+                    (_c = this.pendingTask.resolve) === null || _c === void 0 ? void 0 : _c.forEach(fn => fn());
+                    this.emit('buildSuccess');
                 }
-                else {
-                    yield this.addPkgsToWatch(Object.assign({ compilePkgs }, opts));
+                catch (error) {
+                    this.watching = false;
+                    (_d = this.pendingTask.reject) === null || _d === void 0 ? void 0 : _d.forEach(fn => fn());
+                    this.kill();
+                    this.emit('buildError', { errors: [error.message] });
                 }
-                todoPkgs.forEach(pkg => {
-                    var _a, _b;
-                    (_b = (_a = this.pendingPkgs[pkg].resolve) === null || _a === void 0 ? void 0 : _a.forEach) === null || _b === void 0 ? void 0 : _b.call(_a, fn => fn());
-                    delete this.pendingPkgs[pkg];
-                    this.readyPkgs.push(pkg);
-                });
-            }
-            catch (error) {
-                todoPkgs.forEach(pkg => {
-                    var _a, _b;
-                    (_b = (_a = this.pendingPkgs[pkg].reject) === null || _a === void 0 ? void 0 : _a.forEach) === null || _b === void 0 ? void 0 : _b.call(_a, fn => fn());
-                    delete this.pendingPkgs[pkg];
-                });
-            }
-        }));
-    }
-    compilePkgsAndWatch(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                // if (this.pending || this.watching) {
-                //   return
-                // }
-                this.pending = true;
-                this.emit('buildStart');
-                yield this.call('runTask', Object.assign({ scene: 'watch', action: 'dev' }, opts));
-                this.watching = true;
-                this.emit('buildSuccess');
-            }
-            catch (error) {
-                this.watching = false;
-                this.emit('buildError', error);
-            }
-            finally {
-                this.pending = false;
-            }
-        });
-    }
-    addPkgsToWatch(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { compilePkgs = [] } = opts;
-            try {
-                this.pending = true;
-                this.emit('buildStart');
-                yield this.call('activatePkgs', { compilePkgs });
-                this.emit('buildSuccess');
-            }
-            catch (error) {
-                this.emit('buildError', error);
-            }
-            finally {
-                this.pending = false;
-            }
-        });
-    }
-    changeCompileOptions(options) {
-        this.call('changeCompileOptions', options);
-    }
-    makePkgsReady(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.doCompilePkgs(opts);
-        });
-    }
-    reCompilePkgs(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.readyPkgs = [];
-            this.changeCompileOptions(options);
-            if (!this.pending && !this.watching) {
-                this.pendingPkgs = {};
-            }
-            yield this.doCompilePkgs(options);
-        });
-    }
-}
-class WebPackDevCompiler extends AbstractCompiler {
-    constructor(props) {
-        super(props);
-        this.watching = false;
-        this.inspectPort = 9230;
-        this.createSp();
-    }
-    makePkgsReady(opts) {
-        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
-            if (this.watching) {
-                return resolve(null);
-            }
-            if (this.pendingTask) {
-                (_a = this.pendingTask.resolve) === null || _a === void 0 ? void 0 : _a.push(resolve);
-                (_b = this.pendingTask.reject) === null || _b === void 0 ? void 0 : _b.push(reject);
-                return;
-            }
-            this.pendingTask = {
-                resolve: [resolve],
-                reject: [reject]
-            };
-            try {
-                this.emit('buildStart');
-                yield this.call('runTask', Object.assign({ scene: 'watch', action: 'dev' }, opts));
-                this.watching = true;
-                (_c = this.pendingTask.resolve) === null || _c === void 0 ? void 0 : _c.forEach((fn) => fn());
-                this.emit('buildSuccess');
-            }
-            catch (error) {
-                this.watching = false;
-                (_d = this.pendingTask.reject) === null || _d === void 0 ? void 0 : _d.forEach((fn) => fn());
-                this.kill();
-                this.emit('buildError', error);
-            }
-            finally {
-                this.pendingTask = undefined;
-            }
-        }));
-    }
-    reCompilePkgs(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.watching) {
-                yield this.makePkgsReady(opts);
-                return;
-            }
-            try {
-                this.emit('buildStart');
-                yield this.call('runTask', Object.assign({ action: 'dev', scene: 'reWatch' }, opts));
-                this.emit('buildSuccess');
-            }
-            catch (error) {
-                this.emit('buildError', error);
-            }
-        });
+                finally {
+                    this.pendingTask = undefined;
+                }
+            }));
+        }
+        reCompilePkgs(opts) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!this.watching) {
+                    yield this.makePkgsReady(opts);
+                    return;
+                }
+                try {
+                    this.emit('buildStart');
+                    yield this.call('runTask', Object.assign({ action: 'dev', scene: 'reWatch' }, opts));
+                    this.emit('buildSuccess');
+                }
+                catch (error) {
+                    this.emit('buildError', { errors: [error.message] });
+                }
+            });
+        }
     }
-}
-class BuildCompiler extends AbstractCompiler {
-    constructor(props, args) {
-        super(props, args);
-        this.cps = [];
-        this.inspectPort = 9228;
-        this.createSp();
+    exports.WebPackDevCompiler = WebPackDevCompiler;
+    class BuildCompiler extends AbstractCompiler {
+        constructor(props, args) {
+            super(props, args);
+            this.cps = [];
+            this.workerType = (args === null || args === void 0 ? void 0 : args.workerType) || 'process';
+            this.inspectPort = 9228;
+            this.pool = AbstractCompiler.createPool(this.workerType, {
+                minWorkers: 1
+            }, args);
+            this.pool.emitWorkerMessage = this.emit.bind(this);
+        }
+        build(option) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const res = yield this.call('runTask', Object.assign({ action: 'build' }, option));
+                    return res;
+                }
+                finally {
+                    // 进程不退出，手动kill下
+                    // this.kill()
+                }
+            });
+        }
     }
-    build(option) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const res = yield this.call('runTask', Object.assign({ action: 'build' }, option));
-                return res;
-            }
-            finally {
-                // 进程不退出，手动kill下
-                this.kill();
-            }
-        });
+    exports.BuildCompiler = BuildCompiler;
+    function getProjectCompilerClass(compilerType) {
+        const CompilerClass = compilerType === constant_config_1.COMPILER_TYPE.legacy_dev
+            ? WebPackDevCompiler
+            : compilerType === constant_config_1.COMPILER_TYPE.dev
+                ? MPPackDevCompiler
+                : BuildCompiler;
+        return CompilerClass;
     }
-}
-function getProcessCompilerClass(compilerType) {
-    const CompilerClass = compilerType === constant_config_1.COMPILER_TYPE.legacy_dev
-        ? WebPackDevCompiler
-        : compilerType === constant_config_1.COMPILER_TYPE.dev
-            ? MPPackDevCompiler
-            : BuildCompiler;
-    return CompilerClass;
-}
-exports.getProcessCompilerClass = getProcessCompilerClass;
+    exports.prepareDevPool = AbstractCompiler.prepareDevPool;
+});