webpack support, refreshed build tasks

.eslintrc.json

@@ -0,0 +1,6 @@
+{
+  "rules": {
+    "no-var": 0,
+    "no-console": 0
+  }
+}

build/babel-options.js

@@ -1,11 +1,65 @@
-module.exports = {
-  modules: 'system',
-  moduleIds: false,
-  comments: false,
-  compact: false,
-  stage:2,
-  optional: [
-    "es7.decorators",
-    "es7.classProperties"
-  ]
+var path = require('path');
+var paths = require('./paths');
+
+exports.base = function() {
+  var config = {
+    filename: '',
+    filenameRelative: '',
+    sourceMap: true,
+    sourceRoot: '',
+    moduleRoot: path.resolve('src').replace(/\\/g, '/'),
+    moduleIds: false,
+    comments: false,
+    compact: false,
+    code: true,
+    presets: [ 'es2015-loose', 'stage-1' ],
+    plugins: [
+      'syntax-flow',
+      'transform-decorators-legacy',
+    ]
+  };
+  if (!paths.useTypeScriptForDTS) {
+    config.plugins.push(
+      ['babel-dts-generator', {
+          packageName: paths.packageName,
+          typings: '',
+          suppressModulePath: true,
+          suppressComments: false,
+          memberOutputFilter: /^_.*/,
+          suppressAmbientDeclaration: true
+      }]
+    );
+  };
+  config.plugins.push('transform-flow-strip-types');
+  return config;
+}
+
+exports.commonjs = function() {
+  var options = exports.base();
+  options.plugins.push('transform-es2015-modules-commonjs');
+  return options;
 };
+
+exports.amd = function() {
+  var options = exports.base();
+  options.plugins.push('transform-es2015-modules-amd');
+  return options;
+};
+
+exports.system = function() {
+  var options = exports.base();
+  options.plugins.push('transform-es2015-modules-systemjs');
+  return options;
+};
+
+exports.es2015 = function() {
+  var options = exports.base();
+  options.presets = ['stage-1']
+  return options;
+};
+
+exports['native-modules'] = function() {
+  var options = exports.base();
+  options.presets[0] = 'es2015-loose-native-modules';
+  return options;
+}

build/paths.js

@@ -1,14 +1,31 @@
 var path = require('path');
+var fs = require('fs');
+
+// hide warning //
+var emitter = require('events');
+emitter.defaultMaxListeners = 20;
 
 var appRoot = 'src/';
+var pkg = JSON.parse(fs.readFileSync('./package.json', 'utf-8'));
 
-module.exports = {
+var paths = {
   root: appRoot,
   source: appRoot + '**/*.js',
   html: appRoot + '**/*.html',
   style: 'styles/**/*.css',
   output: 'dist/',
   doc:'./doc',
   e2eSpecsSrc: 'test/e2e/src/*.js',
-  e2eSpecsDist: 'test/e2e/dist/'
+  e2eSpecsDist: 'test/e2e/dist/',
+  packageName: pkg.name,
+  useTypeScriptForDTS: false,
+  importsToAdd: [],
+  sort: false
 };
+
+paths.ignore = ['aurelia-leaflet.js'];
+paths.files = [
+  paths.source
+];
+
+module.exports = paths;

build/tasks/build.js

@@ -3,55 +3,140 @@ var runSequence = require('run-sequence');
 var to5 = require('gulp-babel');
 var paths = require('../paths');
 var compilerOptions = require('../babel-options');
+var compilerTsOptions = require('../typescript-options');
 var assign = Object.assign || require('object.assign');
+var through2 = require('through2');
+var concat = require('gulp-concat');
+var insert = require('gulp-insert');
+var rename = require('gulp-rename');
+var tools = require('aurelia-tools');
+var ts = require('gulp-typescript');
+var gutil = require('gulp-util');
+var gulpIgnore = require('gulp-ignore');
+var merge = require('merge2');
+var jsName = paths.packageName + '.js';
+var compileToModules = ['es2015', 'commonjs', 'amd', 'system', 'native-modules'];
 
-gulp.task('build-html-es6', function () {
-  return gulp.src(paths.html)
-    .pipe(gulp.dest(paths.output + 'es6'));
-});
+function cleanGeneratedCode() {
+  return through2.obj(function(file, enc, callback) {
+    file.contents = new Buffer(tools.cleanGeneratedCode(file.contents.toString('utf8')));
+    this.push(file);
+    return callback();
+  });
+}
 
-gulp.task('build-es6', ['build-html-es6'], function () {
-  return gulp.src(paths.source)
-    .pipe(gulp.dest(paths.output + 'es6'));
-});
+gulp.task('build-index', function() {
+  var importsToAdd = paths.importsToAdd.slice();
 
-gulp.task('build-html-commonjs', function () {
-  return gulp.src(paths.html)
-    .pipe(gulp.dest(paths.output + 'commonjs'));
-});
+  var src = gulp.src(paths.files);
 
-gulp.task('build-commonjs', ['build-html-commonjs'], function () {
-  return gulp.src(paths.source)
-    .pipe(to5(assign({}, compilerOptions, {modules:'common'})))
-    .pipe(gulp.dest(paths.output + 'commonjs'));
-});
+  if (paths.sort) {
+    src = src.pipe(tools.sortFiles());
+  }
+
+  if (paths.ignore) {
+    paths.ignore.forEach(function(filename){
+      src = src.pipe(gulpIgnore.exclude(filename));
+    });
+  }
 
-gulp.task('build-html-amd', function () {
-  return gulp.src(paths.html)
-    .pipe(gulp.dest(paths.output + 'amd'));
+  return src.pipe(through2.obj(function(file, enc, callback) {
+      file.contents = new Buffer(tools.extractImports(file.contents.toString('utf8'), importsToAdd));
+      this.push(file);
+      return callback();
+    }))
+    .pipe(concat(jsName))
+    .pipe(insert.transform(function(contents) {
+      return tools.createImportBlock(importsToAdd) + contents;
+    }))
+    .pipe(gulp.dest(paths.output));
 });
 
-gulp.task('build-amd', ['build-html-amd'], function () {
-  return gulp.src(paths.source)
-    .pipe(to5(assign({}, compilerOptions, {modules:'amd'})))
-    .pipe(gulp.dest(paths.output + 'amd'));
+function gulpFileFromString(filename, string) {
+  var src = require('stream').Readable({ objectMode: true });
+  src._read = function() {
+    this.push(new gutil.File({ cwd: paths.appRoot, base: paths.output, path: filename, contents: new Buffer(string) }))
+    this.push(null)
+  }
+  return src;
+}
+
+function srcForBabel() {
+  return merge(
+    gulp.src(paths.source),
+    gulpFileFromString(paths.output + 'index.js', "export * from './" + paths.packageName + "';")
+  );
+}
+
+function srcForTypeScript() {
+  return gulp
+    .src(paths.output + paths.packageName + '.js')
+    .pipe(rename(function (path) {
+      if (path.extname == '.js') {
+        path.extname = '.ts';
+      }
+    }));
+}
+
+compileToModules.forEach(function(moduleType){
+  gulp.task('build-babel-' + moduleType, function () {
+    return srcForBabel()
+      .pipe(to5(assign({}, compilerOptions[moduleType]())))
+      .pipe(cleanGeneratedCode())
+      .pipe(gulp.dest(paths.output + moduleType));
+  });
+
+  if (moduleType === 'native-modules') return; // typescript doesn't support the combination of: es5 + native modules
+
+  gulp.task('build-ts-' + moduleType, function () {
+    var tsProject = ts.createProject(
+      compilerTsOptions({ module: moduleType, target: moduleType == 'es2015' ? 'es2015' : 'es5' }), ts.reporter.defaultReporter());
+    var tsResult = srcForTypeScript().pipe(ts(tsProject));
+    return tsResult.js
+      .pipe(gulp.dest(paths.output + moduleType));
+  });
 });
 
-gulp.task('build-html-system', function () {
-  return gulp.src(paths.html)
-    .pipe(gulp.dest(paths.output + 'system'));
+gulp.task('build-dts', function() {
+  var tsProject = ts.createProject(
+    compilerTsOptions({ removeComments: false, target: "es2015", module: "es2015" }), ts.reporter.defaultReporter());
+  var tsResult = srcForTypeScript().pipe(ts(tsProject));
+  return tsResult.dts
+    .pipe(gulp.dest(paths.output));
 });
 
-gulp.task('build-system', ['build-html-system'], function () {
-  return gulp.src(paths.source)
-    .pipe(to5(assign({}, compilerOptions, {modules:'system'})))
-    .pipe(gulp.dest(paths.output + 'system'));
+gulp.task('copy-html', function() {
+ return gulp.src(paths.html)
+  .pipe(gulp.dest(paths.output + 'es2015'))
+  .pipe(gulp.dest(paths.output + 'commonjs'))
+  .pipe(gulp.dest(paths.output + 'amd'))
+  .pipe(gulp.dest(paths.output + 'native-modules'))
+  .pipe(gulp.dest(paths.output + 'system'));
+
 });
 
 gulp.task('build', function(callback) {
   return runSequence(
     'clean',
-    ['build-es6', 'build-commonjs', 'build-amd', 'build-system'],
+    'build-index',
+    'copy-html',
+    compileToModules
+      .map(function(moduleType) { return 'build-babel-' + moduleType })
+      .concat(paths.useTypeScriptForDTS ? ['build-dts'] : []),
+    callback
+  );
+});
+
+gulp.task('build-ts', function(callback) {
+  return runSequence(
+    'clean',
+    'build-index',
+    'copy-html',
+    'build-babel-native-modules',
+    compileToModules
+      .filter(function(moduleType) { return moduleType !== 'native-modules' })
+      .map(function(moduleType) { return 'build-ts-' + moduleType })
+      .concat(paths.useTypeScriptForDTS ? ['build-dts'] : []),
     callback
   );
 });

build/tasks/doc.js

@@ -1,14 +1,46 @@
 var gulp = require('gulp');
-var tools = require('aurelia-tools');
 var paths = require('../paths');
-var yuidoc = require('gulp-yuidoc');
+var typedoc = require('gulp-typedoc');
+var runSequence = require('run-sequence');
+var through2 = require('through2');
 
 gulp.task('doc-generate', function(){
-  return gulp.src(paths.source)
-    .pipe(yuidoc.parser(null, 'api.json'))
+  return gulp.src([paths.output + paths.packageName + '.d.ts'])
+    .pipe(typedoc({
+      target: 'es6',
+      includeDeclarations: true,
+      moduleResolution: 'node',
+      json: paths.doc + '/api.json',
+      name: paths.packageName + '-docs', 
+      mode: 'modules',
+      excludeExternals: true,
+      ignoreCompilerErrors: false,
+      version: true
+    }));
+});
+
+gulp.task('doc-shape', function(){
+  return gulp.src([paths.doc + '/api.json'])
+    .pipe(through2.obj(function(file, enc, callback) {
+      var json = JSON.parse(file.contents.toString('utf8')).children[0];
+
+      json = {
+        name: paths.packageName,
+        children: json.children,
+        groups: json.groups
+      };
+
+      file.contents = new Buffer(JSON.stringify(json));
+      this.push(file);
+      return callback();
+    }))
     .pipe(gulp.dest(paths.doc));
 });
 
-gulp.task('doc', ['doc-generate'], function(){
-  tools.transformAPIModel(paths.doc);
+gulp.task('doc', function(callback){
+  return runSequence(
+    'doc-generate',
+    'doc-shape',
+    callback
+  );
 });

build/tasks/lint.js

@@ -2,15 +2,9 @@ var gulp = require('gulp');
 var paths = require('../paths');
 var eslint = require('gulp-eslint');
 
-gulp.task('lint', function () {
-    return gulp.src(paths.source)
-        // eslint() attaches the lint output to the eslint property
-        // of the file object so it can be used by other modules.
-        .pipe(eslint())
-        // eslint.format() outputs the lint results to the console.
-        // Alternatively use eslint.formatEach() (see Docs).
-        .pipe(eslint.format())
-        // To have the process exit with an error code (1) on
-        // lint error, return the stream and pipe to failOnError last.
-        .pipe(eslint.failOnError());
+gulp.task('lint', function() {
+  return gulp.src(paths.source)
+    .pipe(eslint())
+    .pipe(eslint.format())
+    .pipe(eslint.failOnError());
 });