intermediate-component-sa 1.0.4 → 1.1.0

package/tools/tasks/build.bundles.app.ts

@@ -0,0 +1,31 @@
+import { join } from 'path';
+import * as Builder from 'systemjs-builder';
+
+import {
+  BOOTSTRAP_MODULE,
+  JS_PROD_APP_BUNDLE,
+  JS_DEST,
+  SYSTEM_JS_CONFIG_PROD,
+  TMP_CLIENT_DIR,
+  PRESERVE_SOURCE_MAPS,
+} from '../config';
+
+const BUNDLER_OPTIONS = {
+  format: 'cjs',
+  minify: true,
+  mangle: false,
+  sourceMaps: PRESERVE_SOURCE_MAPS,
+};
+
+/**
+ * Executes the build process, bundling the JavaScript files using the SystemJS builder.
+ */
+export = (done: any) => {
+  let builder = new Builder(SYSTEM_JS_CONFIG_PROD);
+  builder
+    .buildStatic(join(TMP_CLIENT_DIR, BOOTSTRAP_MODULE),
+                 join(JS_DEST, JS_PROD_APP_BUNDLE),
+                 BUNDLER_OPTIONS)
+    .then(() => done())
+    .catch((err: any) => done(err));
+};

package/tools/tasks/build.bundles.ts

@@ -0,0 +1,45 @@
+import * as gulp from 'gulp';
+import * as gulpLoadPlugins from 'gulp-load-plugins';
+import * as merge from 'merge-stream';
+
+import { DEPENDENCIES, JS_DEST, JS_PROD_SHIMS_BUNDLE } from '../config';
+
+const plugins = <any>gulpLoadPlugins();
+
+// Uso uglify-es para soportar ES6
+var uglifyEs = require('uglify-es');
+var composer = require('gulp-uglify/composer');
+var minify = composer(uglifyEs, console);
+
+/**
+ * Executes the build process, bundling the shim files.
+ */
+export = () => merge(bundleShims());
+
+/**
+ * Returns the shim files to be injected.
+ */
+function getShims() {
+  let libs = DEPENDENCIES
+    .filter(d => /\.js$/.test(d.src));
+
+  return libs.filter(l => l.inject === 'shims')
+    .concat(libs.filter(l => l.inject === 'libs'))
+    .concat(libs.filter(l => l.inject === true))
+    .map(l => l.src);
+}
+
+/**
+ * Bundles the shim files.
+ */
+function bundleShims() {
+  return gulp.src(getShims())
+    // Strip comments and sourcemaps
+    .pipe(minify({
+      mangle: false
+    }))
+    .pipe(plugins.concat(JS_PROD_SHIMS_BUNDLE))
+    // Strip the first (global) 'use strict' added by reflect-metadata, but don't strip any others to avoid unintended scope leaks.
+    .pipe(plugins.replace(/('|")use strict\1;var Reflect;/, 'var Reflect;'))
+    .pipe(gulp.dest(JS_DEST));
+}

package/tools/tasks/build.database.scripts.runner.ts

@@ -0,0 +1,137 @@
+import { APP_NAME, APP_VERSION, DIST_DIR, APP_DATABASE_SRC  } from '../config';
+//import { MSSQL_TESTING_CONFIG_CREATE, MSSQL_TESTING_CONFIG_USAGE } from '../../src/server/config/mssql.testing.config';
+import { MSSQL_CONFIG } from '../../src/server/config/mssql.config';
+import * as log4js from 'log4js';
+
+// En el proyecto de speechanalytics no hay configuracion para testing
+const MSSQL_TESTING_CONFIG_CREATE: any = MSSQL_CONFIG;
+const MSSQL_TESTING_CONFIG_USAGE: any = MSSQL_CONFIG;
+
+let sql = require('mssql');
+let logger = log4js.getLogger('Sql');
+
+export function createDataBase(): (done: () => void) => void {
+    return done => {
+        let promises: Promise<boolean>[] = [];
+        var queries = readProcessFile(APP_NAME + '_' + APP_VERSION + '_testing_database.sql');
+        queries.forEach(function(query:string){
+            if (query && query !== ' ') {
+                promises.push(makeBulk(query, true).then());
+            }
+        });
+
+        Promise.all(promises)
+        .then(() => {
+            logger.info('Data base creation finished with ' + promises.length + ' queries.');
+            createStructure(done);
+        }).catch(function(err) {
+            if (err.toString().includes('Database \'InconcertTesting\' already exists. Choose a different database name')) {
+                logger.info('Database already exist ...');
+                done();
+            }
+        });
+    };
+}
+
+function createStructure(callback:any) {
+    let promises: Promise<boolean>[] = [];
+    logger.info('Creating Testing Tables');
+    var queries = readProcessFile(APP_NAME + '_' + APP_VERSION + '_testing_structure.sql');
+    queries.forEach(function(query:string){
+        if (query && query !== ' ') {
+            promises.push(makeBulk(query, false).then());
+        }
+    });
+
+    Promise.all(promises).then(() => {
+        logger.info('Data base structure finished with ' + promises.length + ' queries.');
+        createProcedures(callback);
+    });
+}
+
+function createProcedures(callback:any) {
+    let promises: Promise<boolean>[] = [];
+    logger.info('Creating Procedures');
+    var queries = readProcessFile(APP_NAME + '_' + APP_VERSION + '_testing_procedures.sql');
+    queries.forEach(function(query:string){
+        if (query && query !== ' ') {
+            promises.push(makeBulk(query, false).then());
+        }
+    });
+    Promise.all(promises).then(() => {
+        logger.info('Data base procedures finished with ' + promises.length + ' queries.');
+        insertData(callback);
+    });
+}
+
+function insertData(callback:any) {
+    let promises: Promise<boolean>[] = [];
+    logger.info('Insert Testing Data');
+    let queries: any = readProcessFile(APP_NAME + '_' + APP_VERSION + '_testing_data.sql');
+    queries.forEach(function(query:string){
+        if (query && query !== ' ') {
+            promises.push(makeBulk(query, false).then());
+        }
+    });
+    Promise.all(promises).then(() => {
+        logger.info('Data insert finished with ' + promises.length + ' queries.');
+        endDataBaseRestore(callback);
+    });
+}
+
+function endDataBaseRestore(callback:any) {
+    logger.info('Testing DataBase restore Finished');
+    callback();
+}
+
+function readProcessFile(fileName:string): any {
+    var fs = require('fs');
+    var path = require('path');
+    var filePath = path.join(DIST_DIR, fileName);
+
+    return fs.readFileSync(filePath, 'utf-8')
+        .replace(/InconcertOnline/g, MSSQL_TESTING_CONFIG_USAGE.database)
+        .replace(/USE(.*?)$\n/gm,'')
+        .replace(/SET(.*?)$\nGO/gm,'')
+        .replace(/END;/gm,'END')
+        .replace(/--(.*?)$/gm,'')
+        .replace(/(\r\n|\n|\r|\t)/gm,' ')
+        .replace(/    /gm,' ')
+        .replace(/  /gm,' ')
+        .split('GO');
+}
+
+function makeBulk(query:string, create:boolean):Promise <boolean> {
+    let connection: any;
+    if (create) {
+        connection = MSSQL_TESTING_CONFIG_CREATE;
+    } else {
+        connection = MSSQL_TESTING_CONFIG_USAGE;
+
+    }
+    return new sql.connect(connection)
+    .then(
+        (result: any) => {
+            return new sql.Request(result)
+            .batch(query)
+            .then((dump: any) => {
+                result.close();
+                return Promise.resolve(true);
+            })
+            .catch((err: any) => {
+                if ( err.toString().indexOf('Choose a different database name') === 0 ) {
+                    logger.error(' Execution Error: ' +err);
+                    logger.error(query);
+                }
+                return Promise.reject(err);
+            });
+        }
+    ).catch(
+        (err: any) => {
+            if ( err.toString().indexOf('Choose a different database name') === 0 ) {
+                logger.error('Connection Error: ' + err.message);
+            }
+            return Promise.reject(err);
+        }
+    );
+}

package/tools/tasks/build.database.scripts.ts

@@ -0,0 +1,27 @@
+import * as gulp from 'gulp';
+import * as gulpLoadPlugins from 'gulp-load-plugins';
+import { resolve } from 'path';
+
+import { APP_NAME, APP_VERSION, DIST_DIR, APP_DATABASE_SRC } from '../config';
+
+const plugins = <any>gulpLoadPlugins();
+
+const scripts = [
+  resolve(APP_DATABASE_SRC, 'mssql', 'database.sql'),
+  resolve(APP_DATABASE_SRC, 'mssql', 'props.sql'),
+  resolve(APP_DATABASE_SRC, 'mssql', 'schemas.sql'),
+  resolve(APP_DATABASE_SRC, 'mssql', 'users', '**'),
+  resolve(APP_DATABASE_SRC, 'mssql', 'tables', '**'),
+  resolve(APP_DATABASE_SRC, 'mssql', 'functions', '**'),
+  resolve(APP_DATABASE_SRC, 'mssql', 'procedures', '**'),
+  resolve(APP_DATABASE_SRC, 'mssql', 'data', '**'),
+  resolve(APP_DATABASE_SRC, 'mssql', 'initial', '**')
+];
+
+export = () => {
+  return gulp.src(scripts,{allowEmpty: true})
+    .pipe(plugins.count('## sql files selected for bundle'))
+    .pipe(plugins.concat(APP_NAME + '_' + APP_VERSION + '_database.sql'))
+    .pipe(plugins.replace(/CREATE OR ALTER/g, 'CREATE'))
+    .pipe(gulp.dest(resolve(DIST_DIR)));
+};

package/tools/tasks/build.flags.ts

@@ -0,0 +1,9 @@
+import * as gulp from 'gulp';
+import { join } from 'path';
+
+import { FLAGS_SRC, APP_CLIENT_DEST } from '../config';
+
+export = () => {
+  return gulp.src(FLAGS_SRC)
+    .pipe(gulp.dest(join(APP_CLIENT_DEST, 'flags')));
+};

package/tools/tasks/build.fonts.ts

@@ -0,0 +1,9 @@
+import * as gulp from 'gulp';
+import { join } from 'path';
+
+import { FONTS_SRC, APP_CLIENT_DEST } from '../config';
+
+export = () => {
+  return gulp.src(FONTS_SRC)
+    .pipe(gulp.dest(join(APP_CLIENT_DEST, 'fonts')));
+};

package/tools/tasks/build.html_css.ts

@@ -0,0 +1,126 @@
+import * as autoprefixer from 'autoprefixer';
+import * as cssnano from 'cssnano';
+import * as gulp from 'gulp';
+import * as gulpLoadPlugins from 'gulp-load-plugins';
+import * as merge from 'merge-stream';
+import * as log from 'fancy-log';
+import { Chalk } from 'chalk';
+import { join } from 'path';
+import { noop, dummyStream } from '../utils';
+
+import {
+  APP_CLIENT_DEST,
+  APP_CLIENT_SRC,
+  BROWSER_LIST,
+  CSS_DEST,
+  CSS_SRC,
+  DEPENDENCIES,
+  ENV,
+  TMP_CLIENT_DIR,
+  getPluginConfig,
+} from '../config';
+
+// Obtengo plugins de gulp
+const plugins = <any>gulpLoadPlugins();
+const cleanCss = require('gulp-clean-css');
+const gulpConcatCssConfig = getPluginConfig('gulp-concat-css');
+const chalk: Chalk = require('chalk');
+
+const processors = [
+  autoprefixer({
+    browsers: BROWSER_LIST
+  })
+];
+
+const reportPostCssError = (e: any) => log(chalk.red(e.message));
+
+// Obtengo lag de modo producción
+const isProd = ENV === 'prod';
+
+if (isProd) {
+  processors.push(
+    cssnano({
+      discardComments: {removeAll: true},
+      discardUnused: false, // unsafe, see http://goo.gl/RtrzwF
+      zindex: false, // unsafe, see http://goo.gl/vZ4gbQ
+      reduceIdents: false // unsafe, see http://goo.gl/tNOPv0
+    })
+  );
+}
+
+// Copia todos los archivos HTML a la carpeta tmp_client
+function CopyHtmlFilesToTmp() {
+  return gulp.src(join(APP_CLIENT_SRC, '**', '*.html'), { base: APP_CLIENT_SRC })
+    .pipe(gulp.dest(TMP_CLIENT_DIR));
+}
+
+// Procesa y genera los archivos de estilos de componentes de la aplicación
+function GenerateComponentsStylesheets() {
+  return gulp.src(join(APP_CLIENT_SRC, '**', '*.scss'), { base: APP_CLIENT_SRC })
+    .pipe(isProd ? plugins.cached('process-component-scss') : noop())
+    .pipe(isProd ? plugins.progeny() : noop())
+    .pipe(isProd ? noop() : plugins.sourcemaps.init())
+    .pipe(plugins.sass(getPluginConfig('gulp-sass')).on('error', plugins.sass.logError))
+    .pipe(plugins.postcss(processors))
+    .on('error', reportPostCssError)
+    .pipe(isProd ? noop() : plugins.sourcemaps.write('', {
+      sourceMappingURL: function(file) {
+          return '/dist/dev/client/' + file.relative.replace(/\\/g, '/') + '.map';
+      }
+  }))
+  .pipe(gulp.dest(isProd ? TMP_CLIENT_DIR : APP_CLIENT_DEST));
+}
+
+// Procesa y genera los archivos de estilos main y de dependencias externas
+function GenerateMainAndExternalStylesheets() {
+  // Obtengo la combinación de streams para CSS y SCSS y los proceso
+  return merge(GetMainScssStream(), GetExternalCssStream(), GetExternalScssStream())
+    .pipe(isProd ? plugins.concatCss(gulpConcatCssConfig.targetFile, gulpConcatCssConfig.options) : noop())
+    .pipe(plugins.postcss(processors))
+    .on('error', reportPostCssError)
+    .pipe(isProd ? cleanCss() : noop())
+    .pipe(gulp.dest(CSS_DEST));
+}
+
+// Genera el stream de archivos SCSS para procesamiento de dependencias externas
+function GetMainScssStream() {
+  // Devuelvo el array de los archivos, pasados por un cache
+  return gulp.src([
+      join(CSS_SRC, '**', '*.scss'),
+      '!' + join(CSS_SRC, '**', '_*.scss')
+      ], { base: CSS_SRC })
+    .pipe(isProd ? plugins.cached('process-external-scss') : noop())
+    .pipe(isProd ? plugins.progeny() : noop())
+    .pipe(plugins.sass(getPluginConfig('gulp-sass')).on('error', plugins.sass.logError));
+}
+
+// Genera el stream de archivos CSS para procesamiento de dependencias externas
+function GetExternalCssStream() {
+  // Armo el array de dependencias CSS a incluir
+  let globArray: string[] = DEPENDENCIES.filter(dep => /\.css$/.test(dep.src)).map(dep => dep.src);
+  // Si el array es vacío, no sigo (falla gulp)
+  if (!globArray || !globArray.length) return dummyStream();
+  // Devuelvo el array de los archivos, pasados por un cache
+  return gulp.src(globArray,{allowEmpty: true})
+    .pipe(isProd ? plugins.cached('process-external-css') : noop());
+}
+
+// Genera el stream de archivos SCSS para procesamiento de dependencias externas
+function GetExternalScssStream() {
+  // Armo el array de dependencias SCSS a incluir
+  let globArray: string[] = DEPENDENCIES.filter(dep => /\.scss$/.test(dep.src)).map(dep => dep.src);
+  // Si el array es vacío, no sigo (falla gulp)
+  if (!globArray || !globArray.length) return dummyStream();
+  // Devuelvo el array de los archivos, pasados por un cache
+  return gulp.src(globArray,{allowEmpty: true})
+    .pipe(isProd ? plugins.cached('process-external-scss') : noop())
+    .pipe(isProd ? plugins.progeny() : noop())
+    .pipe(plugins.sass(getPluginConfig('gulp-sass')).on('error', plugins.sass.logError));
+}
+
+// Ejecuta y combina todas las tareas en un stream mergeado
+export = () => merge(
+  CopyHtmlFilesToTmp(),
+  GenerateComponentsStylesheets(),
+  GenerateMainAndExternalStylesheets()
+);

package/tools/tasks/build.index.dev.ts

@@ -0,0 +1,68 @@
+import * as gulp from 'gulp';
+import * as gulpLoadPlugins from 'gulp-load-plugins';
+import * as merge from 'merge-stream';
+import * as slash from 'slash';
+import * as replace from 'gulp-replace';
+import { join } from 'path';
+
+import { APP_BASE, APP_CLIENT_DEST, APP_CLIENT_SRC, DEPENDENCIES, CSS_DEST, ASSETS_SRC, TEMPLATE_CONFIG } from '../config';
+import { TemplateLocalsBuilder } from '../utils';
+
+const plugins = <any>gulpLoadPlugins();
+
+
+// Función para inyectar librerías y shims en index.html para caso ambiente de desarrollo
+function buildIndex() {
+  return gulp.src(join(APP_CLIENT_SRC, 'index.html'), { base: APP_CLIENT_SRC })
+    .pipe(inject('shims'))
+    .pipe(inject('libs'))
+    .pipe(inject())
+    .pipe(plugins.template(new TemplateLocalsBuilder().withStringifiedSystemConfigDev().build(), TEMPLATE_CONFIG))
+    .pipe(gulp.dest(APP_CLIENT_DEST));
+}
+
+/**
+ * Injects the file with the given name.
+ * @param {string} name - The file to be injected.
+ */
+function inject(name?: string) {
+  return plugins.inject(gulp.src(getInjectablesDependenciesRef(name), { read: false }), {
+    name,
+    transform: transformPath()
+  });
+}
+
+/**
+ * Returns the injectable dependency, mapping its filename to its path.
+ * @param {string} name - The dependency to be mapped.
+ */
+function getInjectablesDependenciesRef(name?: string) {
+  return DEPENDENCIES
+    .filter(dep => dep['inject'] && dep['inject'] === (name || true))
+    .map(mapPath);
+}
+
+/**
+ * Maps the path of the given dependency to its path according to the applications environment.
+ * @param {any} dep - The dependency to be mapped.
+ */
+function mapPath(dep: any) {
+  let envPath = dep.src;
+  if (envPath.startsWith(APP_CLIENT_SRC) && !envPath.endsWith('.scss')) {
+    envPath = join(APP_CLIENT_DEST, envPath.replace(APP_CLIENT_SRC, ''));
+  } else if (envPath.startsWith(APP_CLIENT_SRC) && envPath.endsWith('.scss')) {
+    envPath = envPath.replace(ASSETS_SRC, CSS_DEST).replace('.scss', '.css');
+  }
+  return envPath;
+}
+
+/**
+ * Transform the path of a dependency to its location within the `dist` directory according to the applications
+ * environment.
+ */
+function transformPath() {
+  return function (filepath: string) {
+    arguments[0] = join(APP_BASE, filepath) + `?${Date.now()}`;
+    return slash(plugins.inject.transform.apply(plugins.inject.transform, arguments));
+  };
+}

package/tools/tasks/build.index.prod.ts

@@ -0,0 +1,64 @@
+import * as gulp from 'gulp';
+import * as gulpLoadPlugins from 'gulp-load-plugins';
+import * as merge from 'merge-stream';
+import * as slash from 'slash';
+import * as replace from 'gulp-replace';
+import { join, sep, normalize } from 'path';
+
+import { APP_CLIENT_BASE, APP_CLIENT_DEST, APP_CLIENT_SRC, CSS_DEST, JS_DEST, JS_PROD_APP_BUNDLE, JS_PROD_SHIMS_BUNDLE, TEMPLATE_CONFIG } from '../config';
+import { TemplateLocalsBuilder } from '../utils';
+
+// Obtengo plugins de gulp
+const plugins = <any>gulpLoadPlugins();
+
+// Función para inyectar dependencias js y css en index.html para caso ambiente de prodcción
+function buildIndex() {
+  return gulp.src(join(APP_CLIENT_SRC, 'index.html'), { base: APP_CLIENT_SRC })
+    .pipe(injectJs())
+    .pipe(injectCss())
+    .pipe(plugins.template(new TemplateLocalsBuilder().withStringifiedSystemConfigDev().build(), TEMPLATE_CONFIG))
+    .pipe(replace(/<!--.*-->/g, ''))
+    .pipe(replace(/\s+(\r\n|\r|\n)/g, '\r\n'))
+    .pipe(replace(/(\r\n|\r|\n){2,}/gm, '\r\n'))
+    .pipe(gulp.dest(APP_CLIENT_DEST));
+}
+
+// Función para hacer inyección de un array de archivos
+function inject(...files: Array<string>) {
+    return plugins.inject(gulp.src(files, { read: false }), {
+        files,
+        transform: transformPath()
+    });
+}
+
+// Inyecta los archivos JS de shims y app
+function injectJs() {
+  return inject(join(JS_DEST, JS_PROD_SHIMS_BUNDLE), join(JS_DEST, JS_PROD_APP_BUNDLE));
+}
+
+// Inyecta los archivos CSS existentes
+function injectCss() {
+  return inject(
+    join(CSS_DEST, '**', '*.css'),
+    '!' + join(CSS_DEST, 'main.css'),
+    '!' + join(CSS_DEST, '**', 'skin-*.css')
+  );
+}
+
+// Hace la transformación del path del archivo para inyectar
+function transformPath() {
+  return function(filepath: string) {
+    let path: Array<string> = normalize(filepath).split(sep);
+    let slice_after = path.indexOf(APP_CLIENT_DEST);
+    if (slice_after>-1) {
+      slice_after++;
+    } else {
+      slice_after = 4;
+    }
+    arguments[0] = APP_CLIENT_BASE + path.slice(slice_after, path.length).join(sep) + `?${Date.now()}`;
+    return slash(plugins.inject.transform.apply(plugins.inject.transform, arguments));
+  };
+}
+
+// Ejecuto todos los builds juntos
+export = () => merge(buildIndex());

package/tools/tasks/build.js.dev.ts

@@ -0,0 +1,66 @@
+import * as gulp from 'gulp';
+import * as gulpLoadPlugins from 'gulp-load-plugins';
+import * as merge from 'merge-stream';
+import * as log from 'fancy-log';
+import { Chalk } from 'chalk';
+import { join } from 'path';
+
+import { APP_CLIENT_DEST, APP_CLIENT_SRC, BOOTSTRAP_MODULE_AOT, TOOLS_DIR, TYPED_COMPILE_INTERVAL, TEMPLATE_CONFIG } from '../config';
+import { makeTsProject, TemplateLocalsBuilder } from '../utils';
+
+// Obtengo plugins de gulp
+const chalk: Chalk = require('chalk');
+const plugins = <any>gulpLoadPlugins();
+
+// Flag de primera ejecución
+let firstTime: boolean = true;
+
+// Ejecuta transpile de los archivos typescript del cliente
+export = () => {
+  // Proyecto de compilación TS
+  let tsProject: any;
+  // Archivos de typings locales
+  let typings = gulp.src([
+    TOOLS_DIR + '/manual_typings/**/*.d.ts'
+  ]);
+  // Archivos a compilar
+  let projectFiles = gulp.src([
+    join(APP_CLIENT_SRC, '**/*.ts'),
+    '!' + join(APP_CLIENT_SRC, '/' + BOOTSTRAP_MODULE_AOT + '.ts'),
+    '!' + join(APP_CLIENT_SRC, '**/*.spec.ts'),
+    '!' + join(APP_CLIENT_SRC, '**/*.e2e-spec.ts'),
+  ]);
+
+  // Solo uso los typings en la primer compilación
+  if (firstTime) {
+    // La primera vez ejecuto build usando los typings manuales
+    tsProject = makeTsProject({}, APP_CLIENT_SRC);
+    projectFiles = merge(typings, projectFiles);
+  } else {
+    // Las siguientes los hago typeless para acelerar
+    tsProject = makeTsProject({ /* isolatedModules: true */ }, APP_CLIENT_SRC);
+    projectFiles = projectFiles.pipe(plugins.cached());
+    log('Fastbuild ' + chalk.cyan('Ejecutando compilación typeless.'));
+  }
+
+  // Actualizo flag
+  firstTime = false;
+
+  // Inicializo proyecto
+  let result: any = projectFiles
+    .pipe(plugins.plumber())
+    .pipe(plugins.sourcemaps.init())
+    .pipe(tsProject());
+
+  return result.js
+    .pipe(plugins.sourcemaps.write())
+    // Use for debugging with Webstorm/IntelliJ
+    // https://github.com/mgechev/angular-seed/issues/1220
+    //    .pipe(plugins.sourcemaps.write('.', {
+    //      includeContent: false,
+    //      sourceRoot: (file: any) =>
+    //        relative(file.path, Config.PROJECT_ROOT + '/' + Config.APP_SRC).replace(sep, '/') + '/' + Config.APP_SRC
+    //    }))
+    .pipe(plugins.template(new TemplateLocalsBuilder().withStringifiedSystemConfigDev().build(), TEMPLATE_CONFIG))
+    .pipe(gulp.dest(APP_CLIENT_DEST));
+};

package/tools/tasks/build.js.prod.aot.ts

@@ -0,0 +1,44 @@
+import { readdirSync, lstatSync } from 'fs';
+import * as gulp from 'gulp';
+import * as gulpLoadPlugins from 'gulp-load-plugins';
+import { join } from 'path';
+
+import { TMP_CLIENT_DIR, TOOLS_DIR, BOOTSTRAP_DIR, BOOTSTRAP_MAIN_AOT, BOOTSTRAP_MODULE_AOT, TEMPLATE_CONFIG } from '../config';
+import { makeTsProject, ngBuildOptimizer, TemplateLocalsBuilder } from '../utils';
+
+const plugins = <any>gulpLoadPlugins();
+
+/**
+ * Executes the build process, transpiling the TypeScript files for the production environment.
+ */
+export = () => {
+
+  const tsProject = makeTsProject({}, TMP_CLIENT_DIR);
+
+  const toIgnore = readdirSync(TMP_CLIENT_DIR)
+    .filter((f: string) => lstatSync(join(TMP_CLIENT_DIR, f)).isDirectory() && f !== BOOTSTRAP_DIR)
+    .map((f: string) => '!' + join(TMP_CLIENT_DIR, f, BOOTSTRAP_MAIN_AOT + '.ts'));
+
+  const src = [
+    TOOLS_DIR + '/manual_typings/**/*.d.ts',
+    join(TMP_CLIENT_DIR, '**/*.ts'),
+    join(TMP_CLIENT_DIR, `${BOOTSTRAP_MODULE_AOT}.ts`),
+    ...toIgnore
+  ];
+
+  const result = gulp
+    .src(src)
+    .pipe(plugins.plumber())
+    .pipe(tsProject())
+    .once('error', function(e: any) {
+      this.once('finish', () => process.exit(1));
+    });
+
+  return result.js
+    .pipe(plugins.template(new TemplateLocalsBuilder().withStringifiedSystemConfigDev().build(), TEMPLATE_CONFIG))
+    .pipe(ngBuildOptimizer())
+    .pipe(gulp.dest(TMP_CLIENT_DIR))
+    .on('error', (e: any) => {
+      console.log(e);
+    });
+};

package/tools/tasks/build.js.prod.rollup.aot.ts

@@ -0,0 +1,50 @@
+import { readdirSync, lstatSync } from 'fs';
+import * as gulp from 'gulp';
+import * as gulpLoadPlugins from 'gulp-load-plugins';
+import { join } from 'path';
+
+import { TMP_CLIENT_DIR, TOOLS_DIR, BOOTSTRAP_DIR, BOOTSTRAP_MAIN_AOT, TEMPLATE_CONFIG } from '../config';
+import { makeTsProject, ngBuildOptimizer, TemplateLocalsBuilder } from '../utils';
+
+const plugins = <any>gulpLoadPlugins();
+
+/**
+ * Executes the build process, transpiling the TypeScript files for the production environment.
+ */
+export = () => {
+
+  const tsProject = makeTsProject(
+    {
+      target: 'es2015',
+      module: 'es2015',
+      moduleResolution: 'node'
+    },
+    TMP_CLIENT_DIR
+  );
+
+  const toIgnore = readdirSync(TMP_CLIENT_DIR)
+    .filter((f: string) => lstatSync(join(TMP_CLIENT_DIR, f)).isDirectory() && f !== BOOTSTRAP_DIR)
+    .map((f: string) => '!' + join(TMP_CLIENT_DIR, f, BOOTSTRAP_MAIN_AOT + '.ts'));
+
+  const src = [
+    join(TOOLS_DIR, '/manual_typings/**/*.d.ts'),
+    join(TMP_CLIENT_DIR, '**/*.ts'),
+    ...toIgnore
+  ];
+
+  const result = gulp
+    .src(src)
+    .pipe(plugins.plumber())
+    .pipe(tsProject())
+    .once('error', function(e: any) {
+      this.once('finish', () => process.exit(1));
+    });
+
+  return result.js
+    .pipe(plugins.template(new TemplateLocalsBuilder().withStringifiedSystemConfigDev().build(), TEMPLATE_CONFIG))
+    .pipe(ngBuildOptimizer())
+    .pipe(gulp.dest(TMP_CLIENT_DIR))
+    .on('error', (e: any) => {
+      console.log(e);
+    });
+};