@omnia/foundation/task/index.js

'use strict';
var processPath = process.cwd().replace(/\\/g, "/")
    , fsExtra = require('fs-extra')
    , del = require('del');

// delete local node_modules
del.sync('node_modules/@omnia/foundation/node_modules');


var gulp = require('gulp')
    , glob = require('glob')
    , chokidar = require('chokidar')
    , fs = require('fs')
    , argv = require('yargs').argv
    , $ = require('gulp-load-plugins')({
        pattern: [
            'gulp-*'
        ],
        rename: {
        }
    })
    , timestamp = require('console-timestamp')
    , path = require('path')
    , webpack = require("webpack")
    , namedModulesPlugin = require('webpack/lib/NamedModulesPlugin')
    , gutil = require("gulp-util")
    , merge = require('webpack-merge')
    , exec = require('child_process').exec
    , jsonfile = require('jsonfile')
    , extend = require('deep-extend')
    , timestamp = require('console-timestamp')
    , path = require('path')
    , omfWebpackPlugins = require('./services/omf.webpack.plugins')
    , utils = require('@omnia/tooling/utils')
    , core = require('@omnia/tooling/core');

var appConfig = {};
mergeConfig();
core.registerBuildTask({ type: core.BuildType.BeforeBuild, order: 9, task: beforeBuild });
core.registerBuildTask({ type: core.BuildType.AfterBuild, order: 20, task: afterBuild });


//gulp.task('aot-compile', function (cb) {
//    mergeConfig()
//        .then(aotCompile)
//        .then(cb);
//})

//gulp.task('webpack-bundle', function (cb) {
//    mergeConfig()
//        .then(webpackBundle)
//        .then(cb);
//});


gulp.task('omf-watch-webpack', function () {
    var listFilesBundling = [];
    process.on('uncaughtException', function (err) {
        console.log(err);
    });

    var watchAngular = chokidar.watch(appConfig.angular.webpack.watch, {
        ignored: /[\/\\]\./,
        persistent: true
    });

    watchAngular.on('ready', function () {
        watchAngular
            .on('change', function (filePath) {
                if (listFilesBundling.indexOf(filePath) === -1) {
                    listFilesBundling.push(filePath);
                    webpackCompile(appConfig.angular.webpack.basePath, appConfig.angular.webpack.flatModules, appConfig.angular.webpack.ignoreFiles, filePath, function () {
                        if (listFilesBundling.indexOf(filePath) > -1)
                            listFilesBundling.splice(listFilesBundling.indexOf(filePath), 1)
                    }, true);
                }
            });
    });
});

function beforeBuild() {
    return new Promise(function (resolve, reject) {
        fsExtra.copySync('node_modules/@omnia/foundation/task/external/node_modules/bin', processPath + '/node_modules/.bin');
        del.sync('node_modules/@types/node');
        del.sync('node_modules/@omnia/foundation/node_modules');
        resolve();
    });
}

function afterBuild() {
    return new Promise(function (resolve, reject) {
        aotCompile()
            .then(webpackBundle)
            .then(resolve)
    });
}

function aotCompile() {
    return new Promise(function (resolve, reject) {
        console.log(timestamp('[hh:mm:ss]') + ' Aot compile running...');

        if (!enableRunAot() && (process.argv.length === 0 || process.argv[process.argv.length - 1] !== '--force-aot')) {
            console.warn('Aot compile disabled in environment.json');
            resolve();
            return;
        }
        if (appConfig.angular.aot.cleanBefore && appConfig.angular.aot.cleanBefore.length > 0) {
            del.sync(appConfig.angular.aot.cleanBefore);
        }
        jsonfile.writeFileSync('./omf.tsconfig.aot.json', appConfig.angular.aot.ngc);
        exec('"node_modules/.bin/ngc" -p ./omf.tsconfig.aot.json', function (err, stdout, stderr) {
            if (stdout)
                console.log(stdout);
            if (stderr)
                console.log(stderr);
            if (err !== null) {
                resolve(err);
                return;
            }
            else {
                if (appConfig.angular.aot.compileAotTsFiles && appConfig.angular.aot.compileAotTsFiles.length > 0) {
                    del.sync('node_modules/@types/node');
                    gulp.src(appConfig.angular.aot.typesForCompileAotTsFiles.concat(appConfig.angular.aot.compileAotTsFiles))
                        .pipe($.tsc({
                            "target": "es5",
                            "module": "commonjs",
                            "moduleResolution": "node",
                            "declaration": false,
                            "sourceMap": false,
                            "removeComments": false,
                            "noImplicitAny": false,
                            "emitDecoratorMetadata": true,
                            "experimentalDecorators": true,
                            "types": []
                        }))
                        .pipe(gulp.dest('.'))
                        .on('end', function () {
                            doWebpackCompile(resolve);
                        });
                }
                else {
                    doWebpackCompile(resolve);
                }
            }
        });
    })

    function doWebpackCompile(resolve) {
        if (appConfig.angular.aot.webpackCompileFiles && appConfig.angular.aot.webpackCompileFiles.length > 0) {
            var totalFiles = 0;
            var countLoop = 0;
            for (var i = 0; i < appConfig.angular.aot.webpackCompileFiles.length; i++) {
                glob(appConfig.angular.aot.webpackCompileFiles[i], function (err, files) {
                    countLoop++;
                    totalFiles = totalFiles + files.length;
                    if (totalFiles === 0 && countLoop === appConfig.angular.aot.webpackCompileFiles.length) {
                        console.log(timestamp('[hh:mm:ss]') + ' Aot compile finished');
                        resolve();
                    }
                    for (var k = 0; k < files.length; k++) {
                        webpackCompile(appConfig.angular.webpack.basePaths, appConfig.angular.webpack.flatModules, appConfig.angular.webpack.ignoreFiles, files[k], function () {
                            totalFiles = totalFiles - 1;
                            if (totalFiles === 0) {
                                if (appConfig.angular.aot.copyOutputAotFilesToTenantResources && appConfig.angular.aot.copyOutputAotFilesToTenantResources.length > 0) {
                                    var count = 0;
                                    for (var j = 0; j < appConfig.angular.aot.copyOutputAotFilesToTenantResources.length; j++) {
                                        gulp.src(appConfig.angular.aot.copyOutputAotFilesToTenantResources[j].source)
                                            .pipe(gulp.dest(appConfig.angular.aot.copyOutputAotFilesToTenantResources[j].target))
                                            .on('end', function () {
                                                count++;
                                                if (count === appConfig.angular.aot.copyOutputAotFilesToTenantResources.length) {
                                                    if (appConfig.angular.aot.cleanAfter && appConfig.angular.aot.cleanAfter.length > 0) {
                                                        del.sync(appConfig.angular.aot.cleanAfter);
                                                    }
                                                    console.log(timestamp('[hh:mm:ss]') + ' Aot compile finished');
                                                    resolve();
                                                }
                                            });
                                    }
                                }
                                else {
                                    if (appConfig.angular.aot.cleanAfter && appConfig.angular.aot.cleanAfter.length > 0) {
                                        del.sync(appConfig.angular.aot.cleanAfter);
                                    }
                                    console.log(timestamp('[hh:mm:ss]') + ' Aot compile finished');
                                    resolve();
                                }
                            }
                        });
                    }
                });
            }
        }
        else {
            if (appConfig.angular.aot.cleanAfter && appConfig.angular.aot.cleanAfter.length > 0) {
                del.sync(appConfig.angular.aot.cleanAfter);
            }
            console.log(timestamp('[hh:mm:ss]') + ' Aot compile finished');
            resolve();
        }
    }
}

function webpackBundle(allowLog) {
    return new Promise(function (resolve, reject) {
        console.log(timestamp('[hh:mm:ss]') + ' Webpack bundle running...');
        var srcfiles = appConfig.angular.webpack.compileFiles;
        var totalFiles = 0;
        var countLoop = 0;

        for (var i = 0; i < srcfiles.length; i++) {
            glob(srcfiles[i], function (err, files) {
                countLoop++;
                totalFiles = totalFiles + files.length;
                for (var k = 0; k < files.length; k++) {
                    webpackCompile(appConfig.angular.webpack.basePaths, appConfig.angular.webpack.flatModules, appConfig.angular.webpack.ignoreFiles, files[k], function () {
                        totalFiles = totalFiles - 1;
                        if (totalFiles === 0 && countLoop === srcfiles.length) {
                            console.log(timestamp('[hh:mm:ss]') + ' Webpack bundle finished');
                            resolve();
                        }
                    }, allowLog);
                }
            });
        }
        if (srcfiles.length === 0) {
            console.log(timestamp('[hh:mm:ss]') + ' Webpack bundle finished');
            resolve();
        }
    })
}


function webpackCompile(basePaths, flatModules, ignoreFiles, destPath, callBack, allowLog) {
    var isSelfResolveModule = false;
    var isCompile = false;
    if (!isMatchIgnoreFiles(ignoreFiles, destPath) && destPath.indexOf('.ngsummary.js') === -1) {
        let stream = fs.readFileSync(destPath, 'utf8');
        isCompile = stream.indexOf('webpackJsonp([0],{') !== 0;
        if (isCompile) {
            isSelfResolveModule = stream.indexOf('.OmniaControl({') > -1 || stream.indexOf('.OmniaAdminControl({') > -1 || stream.indexOf('.NgModule({') > -1 || stream.indexOf('.Component({') > -1
                || stream.indexOf('Extensibility_1.TemplateId') > -1 || stream.indexOf('Extensibility_1.OmniaControl') > -1 || stream.indexOf('<<webpack-resolve-module>>') > -1
        }
    }
    if (isCompile) {
        var namedModulesReplacements = [];
        for (var i = 0; i < basePaths.length; i++) {
            namedModulesReplacements.push({
                pattern: new RegExp(basePaths[i].replace(/\//g, "\\/") + "\\/", 'g'),
                replace: ""
            });
        }
        namedModulesReplacements.push({
            pattern: /\/node_modules/g,
            replace: ""
        });
        fs.appendFileSync(destPath, '\r\n //webpack-eof');
        destPath = "./" + destPath.replace(/[/\\*]/g, "/");
        var fileName = destPath.substring(destPath.lastIndexOf('/'));
        webpack(merge(require("./config/webpack.config.js"), {
            entry: {
                'external': './task/config/external.js',
                'app': destPath
            },
            externals: [
                function (context, request, callback) {
                    if (destPath.indexOf(request.replace("./", "")) === -1 || destPath.substring(destPath.indexOf(request.replace("./", "")), destPath.length) !== request.replace("./", "")) {
                        return callback(null, "__webpack_require__('" + request.toLowerCase() + "')");
                    }
                    else {
                        callback();
                    }
                }
            ],
            cache: false,
            output: {
                pathinfo: true,
                filename: destPath.replace("./", ''),
            },
            plugins: [
                new webpack.optimize.CommonsChunkPlugin({ name: 'external', filename: 'node_modules/@omnia/foundation/task/temp/external.bundle.js' }),
                new omfWebpackPlugins.NamedModulesPlugin({
                    replacements: namedModulesReplacements
                }),
                new omfWebpackPlugins.ReplaceBundlePlugin([
                    {
                        partten: /\/\/# sourceMappingURL[\s\S]+\/\/webpack-eof/g,
                        replacement: function (match) {
                            return '//webpack-eof'
                        }
                    },
                    {
                        partten: /\/\/webpack-eof[\s\S]+}\,\[(.*?)\]/g,
                        replacement: function (match) {
                            return '}},[]'
                        }
                    },
                    {
                        partten: /"use strict";[\s\S]+"use strict";/g,
                        replacement: '"use strict";'
                    },
                    {
                        partten: /\/\* no static exports found[\s\S]+function\(module, exports, __webpack_require__\) {/i,
                        replacement: function (match) { return "function(module, exports, __webpack_require__) {"; }
                    },
                    {
                        partten: /\/\* no static exports found[\s\S]+function\(module, exports\) {/i,
                        replacement: function (match) { return "function(module, exports) {"; }
                    },
                    {
                        partten: /\/\* no static exports found[\s\S]+function\(module, exports\) {/i,
                        replacement: function (match) { return "function(module, exports) {"; }
                    },
                    {
                        partten: new RegExp("__webpack_require__\\(\/\\*(.*)\\)", 'g'),
                        replacement: function (match) {
                            return match
                                .replace("/*!", "'")
                                .replace(/\*\/(.*?)\){1}/i, "')")
                                .replace(/ /g, "")
                                .replace(/'(.*?)'/i, function (requireModulePath) {
                                    requireModulePath = requireModulePath.replace(/'/g, "");
                                    if (requireModulePath.indexOf(".") === 0) {
                                        var requireModulePath = path.resolve(path.dirname(destPath), requireModulePath);
                                        requireModulePath = requireModulePath.replace(/\\/g, "/");
                                        for (var i = 0; i < basePaths.length; i++) {
                                            requireModulePath = requireModulePath.replace(utils.root(basePaths[i]).replace(/\\/g, "/"), "");
                                        }
                                        requireModulePath = requireModulePath
                                            .replace(utils.root('TenantResources').replace(/\\/g, "/") + '/~/', "")
                                            .replace(utils.root('.').replace(/\\/g, "/") + '/~/', "")
                                            .replace(utils.root('.').replace(/\\/g, "/"), "")
                                            .trim("/");
                                        if (requireModulePath.indexOf("/") === 0)
                                            requireModulePath = requireModulePath.substring(1, requireModulePath.length);
                                        if (requireModulePath.indexOf("node_modules/") === 0)
                                            requireModulePath = requireModulePath.replace(/node_modules\//i, "");
                                        if (destPath.indexOf(requireModulePath + '.js') > -1) {
                                            console.log('have recursive import self : ' + destPath);
                                        }
                                    }

                                    return "'" + requireModulePath.toLowerCase().replace("@omnia/foundation/extensibility/typings/", "@omnia/foundation/extensibility/") + "'";
                                });
                        }
                    },
                    {
                        skip: !isSelfResolveModule,
                        partten: /webpackJsonp\(\[0\],{[\s\S]+":/g,
                        replacement: function (match) {
                            var moduleId = match.match(/"(.*?)"/)[1]
                            return "omfExecuteModules.push('" + moduleId + "'); ";
                        },
                        insertToEOF: true
                    },
                    {
                        partten: /;;/g,
                        replacement: ';'
                    },
                ])
            ]
        }), function (err, stats) {
            if (err) throw new gutil.PluginError("webpack", err);
        })
            .plugin("done", function () {
                if (allowLog)
                    console.log('bundle completed - ' + destPath);
                if (callBack !== undefined)
                    callBack();
            });
    }
    else {
        if (callBack !== undefined)
            callBack();
    }
}

function isMatchIgnoreFiles(ignoreFiles, filePath) {
    var isMatch = false
    for (var i = 0; i < ignoreFiles.length; i++) {
        if (filePath.indexOf(ignoreFiles[i]) > -1) {
            isMatch = true;
            return isMatch;
        }
    }

    return isMatch;
}

function enableRunAot() {
    var result = true;
    var processPath = process.cwd().replace(/\\/g, "/");

    if (fs.existsSync(processPath + '/environment.json')) {
        try {
            var config = require(processPath + '/environment.json');
            if (config.Angular && config.Angular && config.Angular.AOT && config.Angular.AOT.RunOnBuild === false)
                result = false
        }
        catch (err) {
            console.log(err);
        }
    }

    return result;
}

function mergeConfig() {
    appConfig = require('./config/app.json');
    var config = core.getConfig('/TaskRunner/Tasks/Angular/task.config.json');
    if (config !== null)
        utils.extend(appConfig, config)
}