intermediate-component-sa 1.0.6 → 1.1.0

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

@@ -0,0 +1,40 @@
+import * as gulp from 'gulp';
+import * as gulpLoadPlugins from 'gulp-load-plugins';
+import { join } from 'path';
+
+import { APP_CLIENT_SRC, TMP_CLIENT_DIR, TOOLS_DIR, BOOTSTRAP_MODULE_AOT, TEMPLATE_CONFIG } from '../config';
+import { makeTsProject, TemplateLocalsBuilder } from '../utils';
+
+const plugins = <any>gulpLoadPlugins();
+
+const INLINE_OPTIONS = {
+  base: TMP_CLIENT_DIR,
+  useRelativePaths: true,
+  removeLineBreaks: true
+};
+
+/**
+ * Executes the build process, transpiling the TypeScript files for the production environment.
+ */
+export = () => {
+
+  let tsProject = makeTsProject({}, APP_CLIENT_SRC);
+
+  let src = [
+    TOOLS_DIR + '/manual_typings/**/*.d.ts',
+    join(TMP_CLIENT_DIR, '**/*.ts'),
+    '!' + join(TMP_CLIENT_DIR, '/' + BOOTSTRAP_MODULE_AOT + '.ts'),
+  ];
+
+  let result = gulp.src(src, { base: TMP_CLIENT_DIR })
+    .pipe(plugins.plumber())
+    .pipe(plugins.inlineNg2Template(INLINE_OPTIONS))
+    .pipe(tsProject())
+    .once('error', function () {
+      this.once('finish', () => process.exit(1));
+    });
+
+  return result.js
+    .pipe(plugins.template(new TemplateLocalsBuilder().withStringifiedSystemConfigDev().build(), TEMPLATE_CONFIG))
+    .pipe(gulp.dest(TMP_CLIENT_DIR));
+};

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

@@ -0,0 +1,19 @@
+import * as gulp from 'gulp';
+import * as gulpLoadPlugins from 'gulp-load-plugins';
+import { resolve } from 'path';
+
+import { APP_SERVER_DEST } from '../config';
+
+const plugins = <any>gulpLoadPlugins();
+
+var jeditor = require('gulp-json-editor');
+
+export = () => {
+  return gulp.src('package.json')
+    .pipe(jeditor(function(json: any) {
+      json.scripts = undefined;
+      json.devDependencies = undefined;
+      return json;
+    }))
+    .pipe(gulp.dest(resolve(APP_SERVER_DEST, '..')));
+};

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

@@ -0,0 +1,59 @@
+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, resolve } from 'path';
+
+import { APP_SERVER_SRC, APP_SERVER_DEST, TOOLS_DIR, 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 servidor
+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_SERVER_SRC, '**/*.ts'),
+    '!' + join(APP_SERVER_SRC, '**/*.spec.ts'),
+    '!' + join(APP_SERVER_SRC, '**/*.e2e-spec.ts'),
+  ], { base: APP_SERVER_SRC });
+
+  // Solo uso los typings en la primer compilación
+  if (firstTime) {
+    // La primera vez ejecuto build usando los typings manuales
+    tsProject = makeTsProject({}, APP_SERVER_SRC);
+    projectFiles = merge(typings, projectFiles);
+  } else {
+    // Las siguientes los hago typeless para acelerar
+    tsProject = makeTsProject({ /* isolatedModules: true */ }, APP_SERVER_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());
+
+  // Ejecuto la compilación y copio el resultado en carpeta destino
+  return result.js
+    .pipe(plugins.sourcemaps.write({ includeContent: false, sourceRoot: resolve('./src/server')}))
+    .pipe(plugins.template(new TemplateLocalsBuilder().withStringifiedSystemConfigDev().build(), TEMPLATE_CONFIG))
+    .pipe(gulp.dest(APP_SERVER_DEST));
+};

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

@@ -0,0 +1,31 @@
+import * as gulp from 'gulp';
+import * as gulpLoadPlugins from 'gulp-load-plugins';
+import { join } from 'path';
+
+import { TMP_SERVER_DIR, TOOLS_DIR, APP_SERVER_SRC, APP_SERVER_DEST, TEMPLATE_CONFIG } from '../config';
+import { makeTsProject, TemplateLocalsBuilder } from '../utils';
+
+const plugins = <any>gulpLoadPlugins();
+
+/**
+ * Executes the build process, transpiling the TypeScript files for the production environment.
+ */
+
+export = () => {
+  let tsProject = makeTsProject({}, APP_SERVER_SRC);
+  let src = [
+    TOOLS_DIR + '/manual_typings/**/*.d.ts',
+    join(TMP_SERVER_DIR, '**/*.ts')
+  ];
+  let result = gulp.src(src, {base: TMP_SERVER_DIR})
+    .pipe(plugins.plumber())
+    .pipe(tsProject())
+    .once('error', function () {
+      this.once('finish', () => process.exit(1));
+    });
+
+
+  return result.js
+    .pipe(plugins.template(new TemplateLocalsBuilder().withStringifiedSystemConfigDev().build(), TEMPLATE_CONFIG))
+    .pipe(gulp.dest(APP_SERVER_DEST));
+};

package/tools/tasks/build.server.statics.ts

@@ -0,0 +1,24 @@
+import * as gulp from 'gulp';
+import * as gulpLoadPlugins from 'gulp-load-plugins';
+import { join } from 'path';
+
+import { APP_SERVER_DEST, TEMPLATE_CONFIG } from '../config';
+import { TemplateLocalsBuilder,  } from '../utils';
+
+const plugins = <any>gulpLoadPlugins();
+
+// Reemplaza todas las variables de template de los archivos estaticos del lado servidor
+export = () => {
+
+  let src = [
+    join(APP_SERVER_DEST, 'static/css/*'),
+    join(APP_SERVER_DEST, 'static/html/*'),
+    join(APP_SERVER_DEST, 'static/js/*')
+  ];
+
+  return gulp.src(src)
+    .pipe(plugins.template(new TemplateLocalsBuilder().withStringifiedSystemConfigDev().build(), TEMPLATE_CONFIG))
+    .pipe(gulp.dest(function(file) {
+      return file.base;
+    }));
+};

package/tools/tasks/build.skins.ts

@@ -0,0 +1,51 @@
+import * as autoprefixer from 'autoprefixer';
+import * as cssnano from 'cssnano';
+import * as gulp from 'gulp';
+import * as gulpLoadPlugins from 'gulp-load-plugins';
+import * as log from 'fancy-log';
+import { Chalk } from 'chalk';
+import { join } from 'path';
+
+import {
+  BROWSER_LIST,
+  SKINS_SRC,
+  CSS_DEST,
+  ENV,
+  getPluginConfig,
+} from '../config';
+
+// Obtengo plugins de gulp
+const plugins = <any>gulpLoadPlugins();
+const chalk: Chalk = require('chalk');
+
+const processors = [
+  autoprefixer({
+    browsers: BROWSER_LIST
+  })
+];
+
+const reportPostCssError = (e: any) => log(chalk.red(e.message));
+
+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
+    })
+  );
+}
+
+export = () => {
+  return gulp.src([
+      join(SKINS_SRC, '**', '*.scss'),
+      '!' + join(SKINS_SRC, '**', '_*.scss')
+    ], {base: SKINS_SRC})
+    .pipe(plugins.sass(getPluginConfig('gulp-sass')).on('error', plugins.sass.logError))
+    .pipe(plugins.postcss(processors))
+    .on('error', reportPostCssError)
+    .pipe(gulp.dest(CSS_DEST));
+};

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

@@ -0,0 +1,6 @@
+import { createSME } from '../utils';
+
+/**
+ * Executes the build process, builds source-map-explorer report
+ */
+export = createSME('prod.aot');

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

@@ -0,0 +1,6 @@
+import { createSME } from '../utils';
+
+/**
+ * Executes the build process, builds source-map-explorer report
+ */
+export = createSME('prod.rollup.aot');

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

@@ -0,0 +1,6 @@
+import { createSME } from '../utils';
+
+/**
+ * Executes the build process, builds source-map-explorer report
+ */
+export = createSME('prod');

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

@@ -0,0 +1,17 @@
+import * as gulp from 'gulp';
+import * as gulpLoadPlugins from 'gulp-load-plugins';
+import { resolve, join } from 'path';
+
+import { APP_NAME, APP_VERSION, DIST_DIR, DIST_PROD_DIR } from '../config';
+
+const plugins = <any>gulpLoadPlugins();
+
+export = () => {
+  return gulp.src(join(DIST_PROD_DIR, '**'), { base : DIST_PROD_DIR })
+        .pipe(plugins.rename(function(path: any) {
+            path.dirname = join('intermediate-component-sa', path.dirname);
+        }))
+        .pipe(plugins.tar(APP_NAME + '_' + APP_VERSION + '.tar'))
+        .pipe(plugins.gzip())
+        .pipe(gulp.dest(DIST_DIR));
+};

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

@@ -0,0 +1,52 @@
+import * as gulp from 'gulp';
+import * as gulpLoadPlugins from 'gulp-load-plugins';
+import { resolve } from 'path';
+import * as merge from 'merge-stream';
+
+
+import { APP_NAME, APP_VERSION, DIST_DIR, APP_DATABASE_SRC } from '../config';
+
+const plugins = <any>gulpLoadPlugins();
+
+const scripts = {
+  database:  resolve(APP_DATABASE_SRC, 'mssql', 'database.sql'),
+  procedures:  resolve(APP_DATABASE_SRC, 'mssql', 'procedures', '**'),
+  tables: [
+    resolve(APP_DATABASE_SRC, 'mssql', 'tables', '**'),
+    resolve(APP_DATABASE_SRC, 'mssql', 'functions', '**'),
+    //resolve(APP_DATABASE_SRC, 'mssql', 'props.sql')
+  ],
+  data: [
+    resolve(APP_DATABASE_SRC, 'mssql', 'data', '**')
+  ]
+};
+
+function createDataBaseScript() {
+  return gulp.src(scripts.database)
+    .pipe(plugins.count('## sql files selected for bundle'))
+    .pipe(plugins.concat(APP_NAME + '_' + APP_VERSION + '_testing_database.sql'))
+    .pipe(gulp.dest(resolve(DIST_DIR)));
+}
+
+function createProceduresScript() {
+  return gulp.src(scripts.procedures)
+    .pipe(plugins.count('## sql files selected for bundle'))
+    .pipe(plugins.concat(APP_NAME + '_' + APP_VERSION + '_testing_procedures.sql'))
+    .pipe(gulp.dest(resolve(DIST_DIR)));
+}
+
+function createTablesScript() {
+  return gulp.src(scripts.tables)
+    .pipe(plugins.count('## sql files selected for bundle'))
+    .pipe(plugins.concat(APP_NAME + '_' + APP_VERSION + '_testing_structure.sql'))
+    .pipe(gulp.dest(resolve(DIST_DIR)));
+}
+
+function createDataScript() {
+  return gulp.src(scripts.data)
+    .pipe(plugins.count('## sql files selected for bundle'))
+    .pipe(plugins.concat(APP_NAME + '_' + APP_VERSION + '_testing_data.sql'))
+    .pipe(gulp.dest(resolve(DIST_DIR)));
+}
+
+export = () => merge(createDataBaseScript(), createTablesScript(), createDataScript(), createProceduresScript());

package/tools/tasks/clean.dev.ts

@@ -0,0 +1,7 @@
+import { DEV_CLIENT_DEST, DEV_SERVER_DEST } from '../config';
+import { clean } from '../utils';
+
+/**
+ * Executes the build process, cleaning all files within the `/dist/dev` directory.
+ */
+export = clean([DEV_CLIENT_DEST, DEV_SERVER_DEST]);

package/tools/tasks/clean.prod.ts

@@ -0,0 +1,7 @@
+import { PROD_CLIENT_DEST, PROD_SERVER_DEST, TMP_CLIENT_DIR } from '../config';
+import { clean } from '../utils';
+
+/**
+ * Executes the build process, cleaning all files within the `/dist/dev` and `dist/tmp` directory.
+ */
+export = clean([PROD_CLIENT_DEST, PROD_SERVER_DEST, TMP_CLIENT_DIR]);

package/tools/tasks/compile.ahead.prod.ts

@@ -0,0 +1,65 @@
+import 'reflect-metadata';
+import { main } from '@angular/compiler-cli/src/main';
+import { readdirSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { argv } from 'yargs';
+
+import { TMP_CLIENT_DIR, PROJECT_ROOT, TOOLS_DIR, BOOTSTRAP_DIR, BOOTSTRAP_MAIN_AOT } from '../config';
+
+const modifyFile = (path: string, mod: any = (f: string) => f) => {
+  // Leo el contenido del archivo
+  const file = readFileSync(path);
+  // Escribo el contenido modificado
+  writeFileSync(path, mod(file.toString()));
+};
+
+const updateCompilerOptions = (options: any, task: string) => {
+  // Actualizo propiedades del tsconfig
+  options.declaration = true;
+  options.sourceMap = false;
+  // Ajustes particulares para el caso rollup
+  if (task.indexOf('rollup') >= 0) {
+    options.module = 'es2015';
+    options.moduleResolution = 'node';
+  }
+};
+
+export = (done: any) => {
+
+  // Hago ajustes en le tsconfig para compilacion AOT y rollup
+  modifyFile(join(TMP_CLIENT_DIR, 'tsconfig.json'), (content: string) => {
+    const parsed = JSON.parse(content);
+    const path = join(PROJECT_ROOT, TOOLS_DIR, 'manual_typings', 'project');
+    updateCompilerOptions(parsed.compilerOptions, argv._[0]);
+    parsed.files = parsed.files || [];
+    parsed.files = parsed.files.concat(
+      readdirSync(path)
+        .filter(f => f.endsWith('d.ts'))
+        .map(f => join(path, f))
+    );
+    parsed.files = parsed.files.filter((f: string, i: number) => parsed.files.indexOf(f) === i);
+    parsed.files.push(join(BOOTSTRAP_DIR, BOOTSTRAP_MAIN_AOT + '.ts'));
+    return JSON.stringify(parsed, null, 2);
+  });
+
+  // Argumentos para la compilación
+  const args: string[] = [
+    '-p', join(TMP_CLIENT_DIR, 'tsconfig.json')
+  ];
+
+  // Ejecuto la compilación
+  return Promise.resolve(main(args))
+  .then(result => {
+    // Verifico si la compilacion fue correcta
+    if (result > 0) {
+      console.error('Compilation failed');
+      process.exit(1);
+    }
+  })
+  .catch((err: any) => {
+    // Algo falló
+    console.error('Compilation failed');
+    console.error(err.stack);
+    process.exit(1);
+  });
+};

package/tools/tasks/copy.client.js.prod.rollup.aot.ts

@@ -0,0 +1,33 @@
+import * as gulp from 'gulp';
+import { join } from 'path';
+
+import { APP_CLIENT_SRC, TMP_CLIENT_DIR } from '../config';
+
+const replace = require('gulp-replace');
+
+/**
+ * Executes the build task, copying all TypeScript files over to the `dist/tmp` directory.
+ */
+export = () => {
+  return gulp.src([
+      join(APP_CLIENT_SRC, 'tsconfig.json'),
+      join(APP_CLIENT_SRC, '**/*.ts'),
+      join(APP_CLIENT_SRC, '**/*.js'),
+      '!' + join(APP_CLIENT_SRC, '**/*.spec.ts'),
+      '!' + join(APP_CLIENT_SRC, '**/*.e2e-spec.ts')
+    ])
+    // import in dev mode: import * as moment from 'moment';
+    // import for rollup:  import moment from 'moment';
+    .pipe(replace('import * as ace from \'brace\';', 'import ace from \'brace\';'))
+    .pipe(replace('import * as dragula from \'dragula\';', 'import dragula from \'dragula\';'))
+    .pipe(replace('import * as jspdf from \'jspdf\';', 'import jspdf from \'jspdf\';'))
+    .pipe(replace('import * as fullcalendar from \'fullcalendar\';', 'import fullcalendar from \'fullcalendar\';'))
+    .pipe(replace('import * as moment from \'moment\';', 'import moment from \'moment\';'))
+    .pipe(replace('import * as timezone from \'moment-timezone\';', 'import timezone from \'moment-timezone\';'))
+    .pipe(replace('import * as screenfull from \'screenfull\';', 'import screenfull from \'screenfull\';'))
+    .pipe(replace('import * as Shuffle from \'shufflejs\';', 'import Shuffle from \'shufflejs\';'))
+    .pipe(replace('import * as socketClient from \'socketClient\';', 'import socketClient from \'socketClient\';'))
+    .pipe(replace('import * as validator from \'validator\';', 'import validator from \'validator\';'))
+    //.pipe(replace('import * as XLSX from \'xlsx\';', 'import XLSX from \'xlsx\';'))
+    .pipe(gulp.dest(TMP_CLIENT_DIR));
+};

package/tools/tasks/copy.client.js.prod.ts

@@ -0,0 +1,18 @@
+import * as gulp from 'gulp';
+import { join } from 'path';
+
+import { APP_CLIENT_SRC, TMP_CLIENT_DIR } from '../config';
+
+/**
+ * Executes the build task, copying all TypeScript files over to the `dist/tmp` directory.
+ */
+export = () => {
+  return gulp.src([
+      join(APP_CLIENT_SRC, 'tsconfig.json'),
+      join(APP_CLIENT_SRC, '**/*.ts'),
+      join(APP_CLIENT_SRC, '**/*.js'),
+      '!' + join(APP_CLIENT_SRC, '**/*.spec.ts'),
+      '!' + join(APP_CLIENT_SRC, '**/*.e2e-spec.ts')
+    ], { base: APP_CLIENT_SRC })
+    .pipe(gulp.dest(TMP_CLIENT_DIR));
+};

package/tools/tasks/copy.server.assets.ts

@@ -0,0 +1,38 @@
+import * as gulp from 'gulp';
+import * as log from 'fancy-log';
+import { Chalk } from 'chalk';
+import { join } from 'path';
+
+import { APP_SERVER_SRC, APP_SERVER_DEST } from '../config';
+
+// Obtengo plugins de gulp
+const chalk: Chalk = require('chalk');
+
+// Flag de primera ejecución
+let firstTime: boolean = true;
+
+// Copia los archivos de la carpeta del servidor hacia el destino
+export = () => {
+
+  // Armo la lista de carpeta origen
+  let src = gulp.src([
+    join(APP_SERVER_SRC, '**/*.*'),
+    '!' + join(APP_SERVER_SRC, '**/*.ts'),
+    '!' + join(APP_SERVER_SRC, 'static/libs/grapesjs/inconcert/**/*.js'),
+    '!' + join(APP_SERVER_SRC, 'static/libs/grapesjs/inconcert/**/*.css'),
+    '!' + join(APP_SERVER_SRC, 'static/libs/grapesjs/inconcert/**/*.scss'),
+    '!' + join(APP_SERVER_SRC, 'static/libs/grapesjs/countdown/**/*.js'),
+    '!' + join(APP_SERVER_SRC, 'static/libs/grapesjs/forms/**/*.js'),
+    ...(firstTime ? [] : ['!' + join(APP_SERVER_SRC, 'template/views/**/*')]),
+    '!' + join(APP_SERVER_SRC, 'tsconfig.json')
+  ], {base: APP_SERVER_SRC});
+
+  // Escribo a log
+  if (!firstTime) log('Fastbuild ' + chalk.cyan('Excluyendo carpeta de templates.'));
+
+  // Actualizo flag
+  firstTime = false;
+
+  // Copio los archivos a la carpeta destino
+  return src.pipe(gulp.dest(APP_SERVER_DEST));
+};

package/tools/tasks/copy.server.js.prod.ts

@@ -0,0 +1,16 @@
+import * as gulp from 'gulp';
+import { join } from 'path';
+
+import { APP_SERVER_SRC, TMP_SERVER_DIR } from '../config';
+
+/**
+ * Executes the build task, copying all TypeScript files over to the `dist/tmp` directory.
+ */
+export = () => {
+  return gulp.src([
+      join(APP_SERVER_SRC, '**/*.ts'),
+      '!' + join(APP_SERVER_SRC, '**/*.spec.ts'),
+      '!' + join(APP_SERVER_SRC, '**/*.e2e-spec.ts')
+    ], {base: APP_SERVER_SRC})
+    .pipe(gulp.dest(TMP_SERVER_DIR));
+};

package/tools/tasks/css-lint.ts

@@ -0,0 +1,58 @@
+import * as colorguard from 'colorguard';
+import * as doiuse from 'doiuse';
+import * as gulp from 'gulp';
+import * as gulpLoadPlugins from 'gulp-load-plugins';
+import * as merge from 'merge-stream';
+import * as reporter from 'postcss-reporter';
+import * as stylelint from 'stylelint';
+import { join } from 'path';
+import { noop } from '../utils';
+
+import { APP_ASSETS, APP_CLIENT_SRC, BROWSER_LIST, CSS_SRC, ENV, DEPENDENCIES, ENABLE_SCSS, COLOR_GUARD_WHITE_LIST, SASS_LINT_OPTIONS } from '../config';
+
+const plugins = <any>gulpLoadPlugins();
+
+const isProd = ENV === 'prod';
+var stylesheetType = ENABLE_SCSS ? 'scss' : 'css';
+
+const processors = [
+  doiuse({
+    browsers: BROWSER_LIST,
+  }),
+  colorguard({
+    whitelist: COLOR_GUARD_WHITE_LIST
+  }),
+  stylelint(),
+  reporter({clearMessages: true})
+];
+
+function lintComponentStylesheets() {
+  return gulp.src([
+    join(APP_CLIENT_SRC, '**', `*.${stylesheetType}`),
+    `!${join(APP_CLIENT_SRC, 'assets', '**', '*.scss')}`,
+    `!${join(CSS_SRC, '**', '*.css')}`
+  ]).pipe(isProd ? plugins.cached('css-lint') : noop())
+    .pipe(ENABLE_SCSS ? plugins.sassLint(SASS_LINT_OPTIONS) : plugins.postcss(processors))
+    .pipe(ENABLE_SCSS ? plugins.sassLint.format() : noop())
+    .pipe(ENABLE_SCSS ? plugins.sassLint.failOnError() : noop());
+}
+
+function lintExternalStylesheets() {
+  return gulp.src(getExternalStylesheets().map(r => r.src))
+    .pipe(isProd ? plugins.cached('css-lint') : noop())
+    .pipe(ENABLE_SCSS ? plugins.sassLint(SASS_LINT_OPTIONS) : plugins.postcss(processors))
+    .pipe(ENABLE_SCSS ? plugins.sassLint.format() : noop())
+    .pipe(ENABLE_SCSS ? plugins.sassLint.failOnError() : noop());
+}
+
+function getExternalStylesheets() {
+  let stylesheets = ENABLE_SCSS ? DEPENDENCIES : APP_ASSETS;
+  return stylesheets
+    .filter(d => new RegExp(`\.${stylesheetType}$`)
+    .test(d.src) && !d.vendor);
+}
+
+/**
+ * Executes the build process, linting the component and external CSS files using `stylelint`.
+ */
+export = () => merge(lintComponentStylesheets(), lintExternalStylesheets());

package/tools/tasks/e2e.ts

@@ -0,0 +1,32 @@
+import * as gulp from 'gulp';
+import { protractor } from 'gulp-protractor';
+
+class Protractor {
+  server(port: number) {
+      return require('../../dist/dev/server').init(port, 'testing');
+  }
+}
+
+/**
+ * Executes the build process, running all e2e specs using `protractor`.
+ */
+export = (done: any) => {
+  new Protractor()
+    .server(9001)
+    .then((server: any) => {
+      gulp
+        .src([])
+        .pipe(protractor({
+          configFile: 'protractor.conf.js',
+          //args: ['--suite', 'login_only']
+          //args: ['--suite', 'login,login_logout']
+          args: ['--suite', 'user_add']
+          //args: ['--suite', 'phone_add']
+          //args: ['--suite', 'environment_add']
+          //args: ['--suite', 'login_logout_borrar']
+          //args: ['--suite', 'template_add']
+          //args: ['--suite', 'prueba']
+        })).on('error', (error: string) => { throw error; })
+        .on('end', () => { server.close(done); });
+    });
+};

package/tools/tasks/karma.run.ts

@@ -0,0 +1,18 @@
+import { startKarma } from '../utils/seed/karma.start';
+/**
+ * Executes the build process, running all unit tests using `karma`.
+ */
+export = (done: any) => {
+  return startKarma(done, {
+    preprocessors: {
+      'dist/**/!(*spec).js': ['coverage']
+    },
+    reporters: ['mocha', 'coverage'],
+    coverageReporter: {
+      dir: 'coverage/',
+      reporters: [
+        { type: 'json', subdir: '.', file: 'coverage-final.json' }
+      ]
+    },
+  });
+};

package/tools/tasks/karma.watch.ts

@@ -0,0 +1,9 @@
+import { startKarma } from '../utils/seed/karma.start';
+/**
+ * Executes the build process, running all unit tests using `karma`.
+ */
+export = (done: any) => {
+  return startKarma(done, {
+    singleRun: false
+  });
+};