Beispiel #1
0
gulp.task('karma:build', () => {
  const typescript = require('gulp-typescript');
  const sourcemaps = require('gulp-sourcemaps');
  const tplinline = require('gulp-inline-ng2-template');
  const errors = require('../utils/errors');
  const paths = require('../config/paths');

  const config = {
    typescript: require('../config/typescript'),
    tplinline: require('../config/tplinline')
  };

  const tsProject = typescript.createProject(paths.typescript.appConfig, config.typescript);

  return gulp
    .src([
      paths.typings,
      paths.sources.scripts,
      '!' + paths.sources.bootstrap,
      '!' + paths.scripts.tests.e2e
    ])
    .pipe(sourcemaps.init())
      .pipe(tplinline(config.tplinline))
      .pipe(typescript(tsProject))
      .js
    .pipe(sourcemaps.write())
    .on('error', errors)
    .pipe(gulp.dest(paths.output.app));
});
Beispiel #2
0
  return new Promise((resolve, reject) => {
    debug(`processAssets ${src} to ${dest}`);

    vfs.src(`${src}/**/*.ts`)
      .pipe(inlineNg2Template({
        base: `${src}`,
        useRelativePaths: true,
        styleProcessor: (path, ext, file, cb) => {

          debug(`render stylesheet ${path}`);
          const render = pickRenderer(path, ext, file);

          debug(`postcss with autoprefixer for ${path}`);
          const browsers = browserslist(undefined, { path });
          render.then((css: string) => postcss([ autoprefixer({ browsers }) ]).process(css))
            .then((result) => {

              result.warnings().forEach((msg) => {
                warn(msg.toString());
              });

              cb(undefined, result.css);
            })
            .catch((err) => {
              cb(err || new Error(`Cannot inline stylesheet ${path}`));
            });

        }
      }))
      .on('error', reject)
      .pipe(vfs.dest(`${dest}`))
      .on('end', resolve);
  });
Beispiel #3
0
gulp.task("build.src", () => {

    var tsResult = gulp.src(["./typings/index.d.ts"].concat(source, specFilesNegate), { base: "./src"})
        .pipe(inlineNg2Template({ useRelativePaths: true, base: "/src/*"}))
        .pipe(sourcemaps.init())
        .pipe(ts(tsProdProject));

    return merge(
        tsResult.js.pipe(sourcemaps.write()).pipe(gulp.dest("./igniteui-js-blocks")),
        tsResult.dts.pipe(gulp.dest("./igniteui-js-blocks"))
    );
});
Beispiel #4
0
gulp.task("build.src", function () {
    
     var tsResult = gulp.src(["./typings/main.d.ts"].concat(source), { base: "./src" })
        .pipe(inlineNg2Template({ useRelativePaths: true, base: '/src/*' }))
        .pipe(sourcemaps.init())
        .pipe(ts(tsProdProject));
    
    // must output to /zero-blocks for module path resolution
    return merge(
        tsResult.js.pipe(sourcemaps.write()).pipe(gulp.dest("./zero-blocks")),
        tsResult.dts.pipe(gulp.dest("./zero-blocks"))
    );
});
Beispiel #5
0
gulp.task('test:buildjs', 'Compile typescript test files', () => {
  let src = argv.files ? `*${(argv.files || '').replace('*','')}*` : '*';
  var tsProject = tsProjectFn();

  var result = gulp.src([
      'typings/browser.d.ts',
      `test/src/**/${src}.ts`
    ])
    .pipe(plumber())
    .pipe(sourcemaps.init())
    .pipe(inlineNg2Template({base: 'test/src', useRelativePaths: true}))
    .pipe(tsc(tsProject));

  return result.js
    .pipe(printFiles())
    .pipe(sourcemaps.write())
    .pipe(gulp.dest('test/src'));
});