初始化

engine/gulp/tasks/buildDebugInfos.js

@@ -0,0 +1,29 @@
+const Fs = require('fs');
+
+module.exports =  function buildDebugInfos () {
+    let readContent = Fs.readFileSync('EngineErrorMap.md', 'utf-8');
+    let titleRegExp = /### \d+/g;
+    let debugInfos = {};
+
+    let result1 = titleRegExp.exec(readContent);
+    while (result1) {
+        let result2 = titleRegExp.exec(readContent);
+        let errInfoHead = result1.index + result1[0].length;
+        let errInfoTail = result2? result2.index: readContent.length;
+
+        let errCode = /\d+/.exec(result1[0])[0];
+        let errInfo = readContent.slice(errInfoHead, errInfoTail);
+        errInfo = errInfo.replace(/```/g, ' ');
+        errInfo = errInfo.trim();
+        errInfo = errInfo.replace(/\r\n/g, '\n');
+
+        if (!errInfo.includes('<!-- DEPRECATED -->')) {
+            debugInfos[`${errCode}`] = errInfo;
+        }
+
+        result1 = result2;
+    }
+
+    let writeContent = JSON.stringify(debugInfos, null, 4);
+    Fs.writeFileSync('DebugInfos.json', writeContent);
+};

engine/gulp/tasks/engine.js

@@ -0,0 +1,544 @@
+/****************************************************************************
+ Copyright (c) 2013-2016 Chukong Technologies Inc.
+
+ https://www.cocos.com/
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated engine source code (the "Software"), a limited,
+ worldwide, royalty-free, non-assignable, revocable and non-exclusive license
+ to use Cocos Creator solely to develop games on your target platforms. You shall
+ not use Cocos Creator software for developing other software or tools that's
+ used for developing games. You are not granted to publish, distribute,
+ sublicense, and/or sell copies of Cocos Creator.
+
+ The software or tools in this License Agreement are licensed, not sold.
+ Xiamen Yaji Software Co., Ltd. reserves all rights not expressly granted to you.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ ****************************************************************************/
+
+'use strict';
+
+const Utils = require('../util/utils');
+const createBundler = require('../util/create-bundler');
+const Path = require('path');
+const Fs = require('fs-extra');
+
+const Source = require('vinyl-source-stream');
+const Gulp = require('gulp');
+const Buffer = require('vinyl-buffer');
+const Sourcemaps = require('gulp-sourcemaps');
+const EventStream = require('event-stream');
+const Chalk = require('chalk');
+const HandleErrors = require('../util/handleErrors');
+const Optimizejs = require('gulp-optimize-js');
+
+let buildSkipModules = [
+    '../../cocos2d/core/platform/deserialize-editor.js',
+];
+
+let physicsSkipModules = [
+    '../../cocos2d/core/3d/physics/exports/physics-builtin.ts',
+    '../../cocos2d/core/3d/physics/exports/physics-cannon.ts',
+    '../../cocos2d/core/3d/physics/exports/physics-framework.ts',
+    '../../cocos2d/core/3d/physics/framework/assets/physics-material.ts',
+    '../../external/cannon/cannon.js',
+];
+
+var jsbSkipModules = [
+    // modules need to skip in jsb
+    '../../extensions/spine/skeleton-cache.js',
+    '../../extensions/spine/vertex-effect-delegate.js',
+    '../../extensions/spine/lib/spine.js',
+    '../../extensions/dragonbones/lib/dragonBones.js',
+    '../../extensions/dragonbones/ArmatureCache.js',
+    '../../extensions/dragonbones/CCArmatureDisplay.js',
+    '../../extensions/dragonbones/CCFactory.js',
+    '../../extensions/dragonbones/CCSlot.js',
+    '../../extensions/dragonbones/CCTextureData.js',
+
+    // gfx
+    '../../cocos2d/renderer/gfx/device.js',
+    '../../cocos2d/renderer/gfx/enums.js',
+    '../../cocos2d/renderer/gfx/frame-buffer.js',
+    '../../cocos2d/renderer/gfx/index-buffer.js',
+    '../../cocos2d/renderer/gfx/misc.js',
+    '../../cocos2d/renderer/gfx/program.js',
+    '../../cocos2d/renderer/gfx/render-buffer.js',
+    '../../cocos2d/renderer/gfx/state.js',
+    '../../cocos2d/renderer/gfx/texture-2d.js',
+    '../../cocos2d/renderer/gfx/texture-cube.js',
+    '../../cocos2d/renderer/gfx/texture.js',
+    '../../cocos2d/renderer/gfx/vertex-buffer.js',
+    '../../cocos2d/renderer/gfx/vertex-format.js',
+
+    // renderer
+    '../../cocos2d/renderer/core/base-renderer.js',
+    '../../cocos2d/renderer/core/program-lib.js',
+    '../../cocos2d/renderer/core/view.js',
+    '../../cocos2d/renderer/renderers/forward-renderer.js',
+    '../../cocos2d/renderer/scene/camera.js',
+    '../../cocos2d/renderer/scene/light.js',
+    '../../cocos2d/renderer/scene/scene.js',
+
+    // buffer
+    '../../cocos2d/core/renderer/webgl/model-batcher.js',
+    '../../cocos2d/core/renderer/webgl/spine-buffer.js',
+];
+var jsbAliasify = {
+    replacements: {
+        // '(.*)render-engine(.js)?': require.resolve('../../cocos2d/core/renderer/render-engine.jsb')
+    },
+    verbose: false
+};
+
+const WEBVIEW_REGEXP = /[Ww]eb[Vv]iew/;
+function excludedWebView (excludes) {
+    return excludes ? excludes.some(item => /.*CCWebView(\.js)?/.test(item)) : false;
+}
+
+exports.buildDebugInfos = require('./buildDebugInfos');
+
+exports.buildCocosJs = function (sourceFile, outputFile, excludes, opt_macroFlags, callback, createMap) {
+    if (typeof opt_macroFlags === 'function') {
+        callback = opt_macroFlags;
+        opt_macroFlags = null;
+    }
+
+    var opts = {
+        sourcemaps: createMap !== false
+    };
+    var outDir = Path.dirname(outputFile);
+    var outFile = Path.basename(outputFile);
+    var bundler = createBundler(sourceFile, opts);
+
+    buildSkipModules.concat(physicsSkipModules).forEach(function (file) {
+        bundler.exclude(require.resolve(file));
+    });
+    excludes && excludes.forEach(function (file) {
+        bundler.exclude(file);
+    });
+
+    bundler = bundler.bundle();
+    bundler = bundler.pipe(Source(outFile));
+    bundler = bundler.pipe(Buffer());
+
+    if (createMap) {
+        bundler = bundler.pipe(Sourcemaps.init({loadMaps: true}));
+    }
+
+    bundler = bundler.pipe(Utils.uglify('build', Object.assign({ debug: true }, opt_macroFlags)));
+    bundler = bundler.pipe(Optimizejs({
+        sourceMap: false
+    }));
+
+    if (createMap) {
+        bundler = bundler.pipe(Sourcemaps.write('./', {
+            sourceRoot: './',
+            includeContent: true,
+            addComment: true
+        }));
+    }
+
+    bundler = bundler.pipe(Gulp.dest(outDir));
+    return bundler.on('end', callback);
+};
+
+exports.buildCocosJsMin = function (sourceFile, outputFile, excludes, opt_macroFlags, callback, createMap) {
+    if (typeof opt_macroFlags === 'function') {
+        callback = opt_macroFlags;
+        opt_macroFlags = null;
+    }
+
+    var opts = {
+        sourcemaps: createMap !== false
+    };
+    var outDir = Path.dirname(outputFile);
+    var outFile = Path.basename(outputFile);
+    var bundler = createBundler(sourceFile, opts);
+
+    buildSkipModules.concat(physicsSkipModules).forEach(function (file) {
+        bundler.exclude(require.resolve(file));
+    });
+    excludes && excludes.forEach(function (file) {
+        bundler.exclude(file);
+    });
+
+    bundler.exclude(Path.resolve(__dirname, '../../DebugInfos.json'));
+
+    var Size = null;
+    try {
+        Size = require('gulp-size');
+    } catch (error) {
+        Size = null;
+    }
+
+    if (Size) {
+        var rawSize = Size({ gzip: false, pretty: false, showTotal: false, showFiles: false });
+        var zippedSize = Size({ gzip: true, pretty: false, showTotal: false, showFiles: false });
+    }
+
+    bundler = bundler.bundle();
+    bundler = bundler.pipe(Source(outFile));
+    bundler = bundler.pipe(Buffer());
+    if (createMap) {
+        console.error('Can not use sourcemap with optimize-js');
+        bundler = bundler.pipe(Sourcemaps.init({loadMaps: true}));
+    }
+    bundler = bundler.pipe(Utils.uglify('build', opt_macroFlags));
+    bundler = bundler.pipe(Optimizejs({
+        sourceMap: false
+    }));
+
+    if (Size) {
+        bundler = bundler.pipe(rawSize);
+        bundler = bundler.pipe(zippedSize);
+        bundler = bundler.pipe(EventStream.through(null, function () {
+            var raw = rawSize.size;
+            var zipped = zippedSize.size;
+            var percent = ((zipped / raw) * 100).toFixed(2);
+            console.log(`Size of ${outputFile}: minimized: ${Chalk.cyan(raw)}B zipped: ${Chalk.cyan(zipped)}B, compression ratio: ${percent}%`);
+            this.emit('end');
+        }));
+    }
+    if (createMap) {
+        bundler = bundler.pipe(Sourcemaps.write('./', {
+            sourceRoot: './',
+            includeContent: true,
+            addComment: true
+        }));
+    }
+    bundler = bundler.pipe(Gulp.dest(outDir));
+    return bundler.on('end', callback);
+};
+
+exports.buildPreview = function (sourceFile, outputFile, callback, devMode) {
+    var cacheDir = devMode && Path.resolve(Path.dirname(outputFile), '.cache/preview-compile-cache');
+    var outFile = Path.basename(outputFile);
+    var outDir = Path.dirname(outputFile);
+
+    var bundler = createBundler(sourceFile, {
+        cacheDir: cacheDir,
+        sourcemaps: !devMode
+    });
+    // NOTE: no need to exclude physics module for cocos2d-js-preview.js
+    var bundler = bundler
+        .bundle()
+        .on('error', HandleErrors.handler)
+        .pipe(HandleErrors())
+        .pipe(Source(outFile))
+        .pipe(Buffer());
+    if (!devMode) {
+        bundler = bundler
+            .pipe(Sourcemaps.init({loadMaps: true}))
+            .pipe(Utils.uglify('preview', {physics_cannon: true}))
+            .pipe(Optimizejs({
+                sourceMap: false
+            }))
+            .pipe(Sourcemaps.write('./', {
+                sourceRoot: '../',
+                includeContent: false,
+                addComment: true
+            }));
+    }
+    bundler
+        .pipe(Gulp.dest(outDir))
+        .on('end', callback);
+};
+
+exports.buildJsbPreview = function (sourceFile, outputFile, excludes, callback) {
+    var FixJavaScriptCore = require('../util/fix-jsb-javascriptcore');
+
+    var outFile = Path.basename(outputFile);
+    var outDir = Path.dirname(outputFile);
+
+    excludes = excludes.concat(jsbSkipModules);
+
+    var bundler = createBundler(sourceFile);
+    // NOTE: no need to exclude physics module for cocos2d-jsb-preview.js
+    excludes.forEach(function (module) {
+        bundler.exclude(require.resolve(module));
+    });
+    bundler.bundle()
+        .on('error', HandleErrors.handler)
+        .pipe(HandleErrors())
+        .pipe(Source(outFile))
+        .pipe(Buffer())
+        .pipe(FixJavaScriptCore())
+        .pipe(Utils.uglify('preview', { jsb: true, nativeRenderer: true, physics_cannon: true}))
+        .pipe(Optimizejs({
+            sourceMap: false
+        }))
+        .pipe(Gulp.dest(outDir))
+        .on('end', callback);
+};
+
+exports.buildJsb = function (sourceFile, outputFile, excludes, opt_macroFlags, callback, createMap) {
+    if (typeof opt_macroFlags === 'function') {
+        callback = opt_macroFlags;
+        opt_macroFlags = null;
+    }
+
+    var opts = {
+        sourcemaps: createMap !== false
+    };
+
+    let flags = Object.assign({ jsb: true, debug: true }, opt_macroFlags);
+    let macro = Utils.getMacros('build', flags);
+    let nativeRenderer = macro["CC_NATIVERENDERER"];
+    let needHandleWebview = excludedWebView(excludes);
+
+    if (opt_macroFlags && nativeRenderer) {
+        opts.aliasifyConfig = jsbAliasify;
+    }
+    if (needHandleWebview) {
+        opts.aliasifyConfig = opts.aliasifyConfig || jsbAliasify;
+        // this will replace require call with an empty object
+        opts.aliasifyConfig.replacements['.*CCWebView(\.js)?'] = false;
+    }
+
+    var FixJavaScriptCore = require('../util/fix-jsb-javascriptcore');
+
+    var outFile = Path.basename(outputFile);
+    var outDir = Path.dirname(outputFile);
+
+    var bundler = createBundler(sourceFile, opts);
+    buildSkipModules.concat(physicsSkipModules).forEach(function (file) {
+        bundler.exclude(require.resolve(file));
+    });
+    if (nativeRenderer) {
+        excludes = excludes.concat(jsbSkipModules);
+    }
+    excludes.forEach(function (module) {
+        bundler.exclude(require.resolve(module));
+    });
+    bundler.bundle()
+        .on('error', HandleErrors.handler)
+        .pipe(HandleErrors())
+        .pipe(Source(outFile))
+        .pipe(Buffer())
+        .pipe(FixJavaScriptCore())
+        .pipe(Utils.uglify('build', flags))
+        .pipe(Optimizejs({
+            sourceMap: false
+        }))
+        .on('data', function (file) {
+            if (needHandleWebview) {
+                let contents = file.contents.toString();
+                if (WEBVIEW_REGEXP.test(contents)) {
+                    throw new Error('WebView field still exists in engine');
+                }
+            }
+        })
+        .pipe(Gulp.dest(outDir))
+        .on('end', callback);
+};
+
+exports.buildJsbMin = function (sourceFile, outputFile, excludes, opt_macroFlags, callback, createMap) {
+    if (typeof opt_macroFlags === 'function') {
+        callback = opt_macroFlags;
+        opt_macroFlags = null;
+    }
+
+    var opts = {
+        sourcemaps: createMap !== false
+    };
+
+    let flags = Object.assign({ jsb: true }, opt_macroFlags);
+    let macro = Utils.getMacros('build', flags);
+    let nativeRenderer = macro["CC_NATIVERENDERER"];
+    let needHandleWebview = excludedWebView(excludes);
+
+    if (opt_macroFlags && nativeRenderer) {
+        opts.aliasifyConfig = jsbAliasify;
+    }
+    if (needHandleWebview) {
+        opts.aliasifyConfig = opts.aliasifyConfig || jsbAliasify;
+        // this will replace require call with an empty object
+        opts.aliasifyConfig.replacements['.*CCWebView(\.js)?'] = false;
+    }
+
+    var FixJavaScriptCore = require('../util/fix-jsb-javascriptcore');
+
+    var outFile = Path.basename(outputFile);
+    var outDir = Path.dirname(outputFile);
+
+    var bundler = createBundler(sourceFile, opts);
+    buildSkipModules.concat(physicsSkipModules).forEach(function (file) {
+        bundler.exclude(require.resolve(file));
+    });
+    if (nativeRenderer) {
+        excludes = excludes.concat(jsbSkipModules);
+    }
+    excludes.forEach(function (module) {
+        bundler.exclude(require.resolve(module));
+    });
+
+    bundler.exclude(Path.resolve(__dirname, '../../DebugInfos.json'));
+
+    bundler.bundle()
+        .on('error', HandleErrors.handler)
+        .pipe(HandleErrors())
+        .pipe(Source(outFile))
+        .pipe(Buffer())
+        .pipe(FixJavaScriptCore())
+        .pipe(Utils.uglify('build', flags))
+        .pipe(Optimizejs({
+            sourceMap: false
+        }))
+        .on('data', function (file) {
+            if (needHandleWebview) {
+                let contents = file.contents.toString();
+                if (WEBVIEW_REGEXP.test(contents)) {
+                    throw new Error('WebView field still exists in engine');
+                }
+            }
+        })
+        .pipe(Gulp.dest(outDir))
+        .on('end', callback);
+};
+
+exports.buildRuntime = function (sourceFile, outputFile, excludes, opt_macroFlags, callback, createMap) {
+    if (typeof opt_macroFlags === 'function') {
+        callback = opt_macroFlags;
+        opt_macroFlags = null;
+    }
+
+    var opts = {
+        sourcemaps: createMap !== false
+    };
+
+    let flags = Object.assign({ jsb: false, runtime: true, debug: true }, opt_macroFlags);
+    let macro = Utils.getMacros('build', flags);
+    let nativeRenderer = macro["CC_NATIVERENDERER"];
+
+    if (opt_macroFlags && nativeRenderer) {
+        opts.aliasifyConfig = jsbAliasify;
+    }
+
+    var FixJavaScriptCore = require('../util/fix-jsb-javascriptcore');
+
+    var outFile = Path.basename(outputFile);
+    var outDir = Path.dirname(outputFile);
+
+    var bundler = createBundler(sourceFile, opts);
+    buildSkipModules.concat(physicsSkipModules).forEach(function (file) {
+        bundler.exclude(require.resolve(file));
+    });
+    excludes.forEach(function (module) {
+        bundler.exclude(require.resolve(module));
+    });
+
+    bundler.bundle()
+        .on('error', HandleErrors.handler)
+        .pipe(HandleErrors())
+        .pipe(Source(outFile))
+        .pipe(Buffer())
+        .pipe(FixJavaScriptCore())
+        .pipe(Utils.uglify('build', flags))
+        .pipe(Optimizejs({
+            sourceMap: false
+        }))
+        .pipe(Gulp.dest(outDir))
+        .on('end', callback);
+};
+
+exports.buildRuntimeMin = function (sourceFile, outputFile, excludes, opt_macroFlags, callback, createMap) {
+    if (typeof opt_macroFlags === 'function') {
+        callback = opt_macroFlags;
+        opt_macroFlags = null;
+    }
+
+    var opts = {
+        sourcemaps: createMap !== false
+    };
+
+    let flags = Object.assign({ jsb: false, runtime: true }, opt_macroFlags);
+    let macro = Utils.getMacros('build', flags);
+    let nativeRenderer = macro["CC_NATIVERENDERER"];
+
+    if (opt_macroFlags && nativeRenderer) {
+        opts.aliasifyConfig = jsbAliasify;
+    }
+    
+    var FixJavaScriptCore = require('../util/fix-jsb-javascriptcore');
+
+    var outFile = Path.basename(outputFile);
+    var outDir = Path.dirname(outputFile);
+
+    var bundler = createBundler(sourceFile, opts);
+    buildSkipModules.concat(physicsSkipModules).forEach(function (file) {
+        bundler.exclude(require.resolve(file));
+    });
+    excludes.forEach(function (module) {
+        bundler.exclude(require.resolve(module));
+    });
+
+    bundler.exclude(Path.resolve(__dirname, '../../DebugInfos.json'));
+
+    bundler.bundle()
+        .on('error', HandleErrors.handler)
+        .pipe(HandleErrors())
+        .pipe(Source(outFile))
+        .pipe(Buffer())
+        .pipe(FixJavaScriptCore())
+        .pipe(Utils.uglify('build', flags))
+        .pipe(Optimizejs({
+            sourceMap: false
+        }))
+        .pipe(Gulp.dest(outDir))
+        .on('end', callback);
+};
+
+exports.excludeAllDepends = function (excludedModules) {
+    let modules = Fs.readJsonSync(Path.join(__dirname, '../../modules.json'));
+    if (modules && modules.length > 0) {
+        function _excludeMudules (muduleName) {
+            if (excMudules[muduleName]) {
+                return;
+            }
+            for (let module of modules) {
+                if (module.name === muduleName) {
+                    excMudules[muduleName] = module;
+                    break;
+                }
+            }
+
+            modules.forEach(module => {
+                if (module.dependencies && module.dependencies.indexOf(muduleName) !== -1) {
+                    _excludeMudules(module.name);
+                }
+            });
+        }
+
+        // exclude all mudules
+        let excMudules = Object.create(null);
+
+        excludedModules.forEach(_excludeMudules);
+
+        let excludes = [];
+        for (let key in excMudules) {
+            let module = excMudules[key];
+            if (module.entries) {
+                module.entries.forEach(function (file) {
+                    let path = Path.join(__dirname, '..', '..', file);
+                    if (excludes.indexOf(path) === -1) {
+                        excludes.push(path);
+                    }
+                });
+            }
+        }
+        return excludes;
+    }
+    else {
+        return [];
+    }
+};
+
+exports.jsbSkipModules = jsbSkipModules;

engine/gulp/tasks/test.js

@@ -0,0 +1,169 @@
+/****************************************************************************
+ Copyright (c) 2013-2016 Chukong Technologies Inc.
+
+ https://www.cocos.com/
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated engine source code (the "Software"), a limited,
+ worldwide, royalty-free, non-assignable, revocable and non-exclusive license
+ to use Cocos Creator solely to develop games on your target platforms. You shall
+ not use Cocos Creator software for developing other software or tools that's
+ used for developing games. You are not granted to publish, distribute,
+ sublicense, and/or sell copies of Cocos Creator.
+
+ The software or tools in this License Agreement are licensed, not sold.
+ Xiamen Yaji Software Co., Ltd. reserves all rights not expressly granted to you.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ ****************************************************************************/
+
+const UGLIFY = false;
+
+'use strict';
+
+const Path = require('path');
+const Fs = require('fs');
+const Source = require('vinyl-source-stream');
+const Gulp = require('gulp');
+const Fb = require('gulp-fb');
+const Babel = require('gulp-babel');
+const Buffer = require('vinyl-buffer');
+const HandleErrors = require('../util/handleErrors');
+const Es = require('event-stream');
+
+const Sourcemaps = require('gulp-sourcemaps');
+
+const Utils = require('../util/utils');
+const createBundler = require('../util/create-bundler');
+
+exports.build = function (sourceFile, outputFile, sourceFileForExtends, outputFileForExtends, sourcemaps, callback) {
+    var cacheDir = Path.resolve(Path.dirname(outputFile), '.cache/test-compile-cache');
+    var engine = createBundler(sourceFile, {
+        sourcemaps: sourcemaps,
+        cacheDir: cacheDir
+    })
+        .bundle()
+        .on('error', HandleErrors.handler)
+        .pipe(HandleErrors())
+        .pipe(Source(Path.basename(outputFile)))
+        .pipe(Buffer());
+
+    if (UGLIFY) {
+        if (sourcemaps) {
+            engine = engine.pipe(Sourcemaps.init({loadMaps: true}));
+        }
+
+        // remove `...args` used in CC_JSB
+        engine = engine.pipe(Utils.uglify('test'));
+
+        if (sourcemaps) {
+            engine = engine.pipe(Sourcemaps.write('./', {
+                sourceRoot: '../',
+                includeContent: false,
+                addComment: true
+            }));
+        }
+    }
+
+    engine = engine.pipe(Gulp.dest(Path.dirname(outputFile)));
+
+    if (Fs.existsSync(sourceFileForExtends)) {
+        var engineExtends = createBundler(sourceFileForExtends, {
+                presets: [
+                    [
+                        require('@babel/preset-env'),
+                        {
+                            loose: true,
+                            // bugfixes: true, since babel 7.9
+                            targets: 'PhantomJS 2.1',
+                        }
+                    ],
+                ],
+                plugins: [
+                    require('@babel/plugin-transform-runtime')
+                ],
+                sourcemaps,
+                cacheDir,
+                bundleExternal: true,
+            })
+            .bundle()
+            .on('error', HandleErrors.handler)
+            .pipe(HandleErrors())
+            .pipe(Source(Path.basename(outputFileForExtends)))
+            .pipe(Buffer())
+            .pipe(Gulp.dest(Path.dirname(outputFileForExtends)));
+        Es.merge(engine, engineExtends).on('end', callback);
+    }
+    else {
+        engine.on('end', callback);
+    }
+};
+
+exports.unit = function (outDir, libs, callback) {
+    var title = 'CocosCreator Engine Test Suite';
+    if (Fs.existsSync('./bin/cocos2d-js-extends-for-test.js')) {
+        libs.push('./bin/cocos2d-js-extends-for-test.js');
+        title += ' (Editor Extends Included)';
+    }
+    return Gulp.src(['test/qunit/unit-es5/**/*.js', './bin/test/**/*.js'], { read: false, base: './' })
+        .pipe(Fb.toFileList())
+        .pipe(Fb.generateRunner('test/qunit/lib/qunit-runner.html', outDir, title, libs))
+        .pipe(Gulp.dest(outDir))
+        .on('end', callback);
+};
+
+exports.test = function (callback) {
+    var qunit;
+    try {
+        qunit = require('gulp-qunit');
+    } catch (e) {
+        console.error('Please run "npm install gulp-qunit@2.0.1 -g" before running "gulp test".');
+        throw e;
+    }
+    return Gulp.src('bin/qunit-runner.html')
+        .pipe(qunit({ timeout: 15 }))
+        .on('end', callback);
+};
+
+exports.buildTestCase = function (outDir, callback) {
+    return Gulp.src('test/qunit/unit/**/*.js')
+        .pipe(Babel({
+            presets: [
+                [
+                    require('@babel/preset-env'),
+                    {
+                        "loose": true,
+                        // "bugfixes": true, since babel 7.9
+                        "targets": "PhantomJS 2.1"
+                    }
+                ]
+            ],
+            plugins: [
+                // make sure that transform-decorators-legacy comes before transform-class-properties.
+                [
+                    require('@babel/plugin-proposal-decorators'),
+                    { legacy: true },
+                ],
+                [
+                    require('@babel/plugin-proposal-class-properties'),
+                    { loose: true },
+                ],
+                [
+                    require('babel-plugin-add-module-exports'),
+                ],
+            ],
+            ast: false,
+            babelrc: false,
+            highlightCode: false,
+            sourceMap: true,
+            compact: false
+        }))
+        .pipe(Gulp.dest(outDir))
+        .on('end', callback);
+};

engine/gulp/tasks/watch.js

@@ -0,0 +1,108 @@
+var Watchify = require('watchify');
+var Browserify = require('browserify');
+var Fs = require('fs');
+
+var Path = require('path');
+var through = require('through');
+
+var Engine = require('./engine');
+
+// var source = require('vinyl-source-stream');
+// var buffer = require('vinyl-buffer');
+// var sourcemaps = require('gulp-sourcemaps');
+
+function watchFile(opts) {
+    var bundler = new Browserify(opts.entries, {
+        cache: {},
+        packageCache: {},
+        debug: true,
+        detectGlobals: false,    // dont insert `process`, `global`, `__filename`, and `__dirname`
+        bundleExternal: false,   // dont bundle external modules
+        plugin: [Watchify]
+    });
+     
+    bundler.on('update', bundle);
+
+    if (opts.skips) {
+        var skips = opts.skips;
+        for (var i = 0; i < skips.length; ++i) {
+            var file = require.resolve(skips[i]);
+            bundler.ignore(file);
+        }    
+    }
+     
+    function bundle() {
+        var name = new Date().toTimeString() + ' : browserify for ' + opts.dest + '.   ';
+        console.time(name);
+
+        // append prefix to index.js
+        var prefix = '';
+        if (opts.prefix) {
+            if (typeof opts.prefix === 'function') {
+                prefix = opts.prefix();
+            }
+            else if (typeof opts.prefix === 'string') {
+                prefix = opts.prefix;
+            }
+        }
+
+        bundler.transform(function (file) {
+            var data = '';
+            
+            if (Path.basename(file) === 'index.js') {
+                data += prefix;
+            }
+
+            return through(write, end);
+
+            function write (buf) { data += buf; }
+            function end () {
+                this.queue(data);
+                this.queue(null);
+            }
+            return;
+        });
+
+        // do bundle
+        var b = bundler.bundle();
+
+        b.on('end', function () {
+            console.timeEnd(name);
+        });
+
+        b = b.pipe(Fs.createWriteStream(opts.dest));
+
+        // fixed chinese character in source maps
+        // b = b.pipe(source(Path.basename(opts.dest)))
+        //     .pipe(buffer())
+        //     .pipe(sourcemaps.init({loadMaps: true}))
+        //     .pipe(sourcemaps.write('./'))
+        //     .pipe(gulp.dest(Path.dirname(opts.dest)));
+        
+        return b;
+    }
+    
+    return bundle();
+}
+
+exports.preview = function (sourceFile, outputFile) {
+    return watchFile({
+        entries: sourceFile,
+        dest: outputFile,
+        prefix: 'CC_DEV = true;\n'
+    });
+};
+
+exports.jsbPolyfill = function (sourceFile, outputFile) {
+    return watchFile({
+        entries: sourceFile,
+        dest: outputFile,
+        prefix: function () {
+            var prefix = 'CC_DEV = true;\n';
+            prefix += 'CC_JSB = true;\n';
+
+            return prefix;
+        },
+        skips: Engine.jsbSkipModules
+    });
+};