build-boiler/gulp/tasks/assemble/index.js

Build Boilerplate using Webpack, Eslint, Assemble, Nunjucks, and BrowserSync

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

exports.default = function (gulp, plugins, config) {
  var _arguments = arguments;
  var browserSync = plugins.browserSync;
  var gutil = plugins.gutil;
  var colors = gutil.colors;
  var log = gutil.log;
  var blue = colors.blue;
  var assembleParentConfig = config.assemble;
  var sources = config.sources;
  var utils = config.utils;
  var environment = config.environment;
  var webpackConfig = config.webpackConfig;
  var srcDir = sources.srcDir;
  var buildDir = sources.buildDir;
  var templateDir = sources.templateDir;
  var globalStatsFile = sources.globalStatsFile;
  var statsFile = sources.statsFile;
  var addbase = utils.addbase;
  var logError = utils.logError;
  var isDev = environment.isDev;
  var enableIsomorphic = environment.enableIsomorphic;

  var plasma = new _plasma2.default();
  var app = new _assembleCore2.default();
  var templatePath = addbase(srcDir, templateDir);
  var src = (0, _path.join)(templatePath, 'pages/**/*.html');
  var statsDir = addbase(buildDir);
  var globalStatsPath = (0, _path.join)(statsDir, globalStatsFile);
  var parentData = assembleParentConfig.data;
  var registerTags = assembleParentConfig.registerTags;
  var _assembleParentConfig = assembleParentConfig.middleware;
  var parentMiddlware = _assembleParentConfig === undefined ? {} : _assembleParentConfig;

  var tools = (0, _isomorpicTools2.default)(_lodash2.default.assign({}, config, {
    isPlugin: false,
    isMainTask: true
  }));

  if (isDev) {
    var watch = require('base-watch');
    app.use(watch());
  }

  plasma.dataLoader('yml', function (fp) {
    var str = (0, _fs.readFileSync)(fp, 'utf8');
    return (0, _jsYaml.safeLoad)(str);
  });

  function makeTemplatePath(dir) {
    return function (fp) {
      return (0, _path.join)(templatePath, dir, fp) + '.html';
    };
  }

  app.data(_extends({
    sources: sources,
    environment: environment,
    webpackConfig: webpackConfig,
    join: _path.join,
    layouts: makeTemplatePath('layouts'),
    macros: makeTemplatePath('macros'),
    partials: makeTemplatePath('partials')
  }, parentData));

  var nunj = _nunjucks2.default.configure({
    watch: false,
    noCache: true
  });

  (0, _customTags2.default)(nunj, app, {
    isomorphic: enableIsomorphic,
    fn: registerTags
  });

  (0, _middleware2.default)(app, config, parentMiddlware);

  app.engine('.html', _consolidate2.default.nunjucks);

  app.option('renameKey', _renameKey2.default);

  function makeStats(main, global) {
    var images = global.assets;

    var rest = _objectWithoutProperties(global, ['assets']);

    return _lodash2.default.merge({}, main, rest, { images: images });
  }

  return function (cb) {
    var prom = undefined;

    if (enableIsomorphic) {
      prom = tools.development(isDev).server(statsDir).then(function () {
        return Promise.resolve(makeStats(tools.assets(), (0, _fsExtra.readJsonSync)(globalStatsPath)));
      });
    } else {
      prom = new Promise(function (res, rej) {
        var statsPaths = [(0, _path.join)(statsDir, statsFile), globalStatsPath];

        _async2.default.map(statsPaths, _fsExtra2.default.readJson, function (err, results) {
          if (err) return res({});

          var _results = _slicedToArray(results, 2);

          var main = _results[0];
          var global = _results[1];


          res(makeStats(main, global));
        });
      });
    }

    prom.then(function (assets) {
      app.data({ assets: assets });

      var parentConfig = (0, _runParentFn2.default)(_arguments, {
        src: src,
        data: {
          app: app,
          assets: assets,
          nunj: nunj,
          jsxLoader: _jsxLoader2.default
        }
      });

      var newSrc = parentConfig.src;
      var data = parentConfig.data;
      var fn = parentConfig.fn;


      var task = function task(done) {
        if (enableIsomorphic) {
          (function () {
            var isomorphic = config.isomorphic;
            var cwd = isomorphic.context;
            var componentEntries = isomorphic.entries;

            /**
             * Create the isomorphic "snippets"
             */

            app.create('snippets', { viewType: 'partial', renameKey: _renameKey2.default }).use(_jsxLoader2.default);

            app.task('template', function (done) {
              app.snippets.load(componentEntries, { cwd: cwd }, config, function (err) {
                if (err) {
                  logError({ err: err, plugin: '[template-assemble]: error templating .jsx template' });
                }

                done(null);
              });
            });
          })();
        }

        app.task('build', enableIsomorphic && !isDev ? ['template'] : [], function () {
          var stream = app.src(newSrc).pipe((0, _isomorphicMergePlugin2.default)(app, config)).pipe(app.renderFile()).pipe(app.dest(buildDir)).on('data', function (file) {
            log('Rendered ' + blue((0, _renameKey2.default)(file.path)));
          }).on('error', function (err) {
            logError({ err: err, plugin: '[assemble]: build' });
          });

          if (isDev) {
            stream = stream.pipe(browserSync.stream());
          }

          return stream;
        });

        app.task('watch', ['build'], function () {
          var watchBase = data.watch || addbase(srcDir, '{templates,config}/**/*.{html,yml}');

          app.watch(watchBase, ['build']);
          done();
        });

        app.build(isDev ? ['watch'] : ['build'], function (err) {
          if (err) {
            logError({ err: err, plugin: '[assemble]: run' });
          }
          done();
        });
      };

      (0, _runCustomTask2.default)(task, fn, cb);
    }).catch(function (err) {
      logError({ err: err, plugin: '[assemble: server]' });
    });
  };
};

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _assembleCore = require('assemble-core');

var _assembleCore2 = _interopRequireDefault(_assembleCore);

var _nunjucks = require('nunjucks');

var _nunjucks2 = _interopRequireDefault(_nunjucks);

var _fsExtra = require('fs-extra');

var _fsExtra2 = _interopRequireDefault(_fsExtra);

var _consolidate = require('consolidate');

var _consolidate2 = _interopRequireDefault(_consolidate);

var _jsYaml = require('js-yaml');

var _fs = require('fs');

var _path = require('path');

var _async = require('async');

var _async2 = _interopRequireDefault(_async);

var _plasma = require('plasma');

var _plasma2 = _interopRequireDefault(_plasma);

var _customTags = require('./custom-tags');

var _customTags2 = _interopRequireDefault(_customTags);

var _middleware = require('./middleware');

var _middleware2 = _interopRequireDefault(_middleware);

var _jsxLoader = require('./jsx-loader');

var _jsxLoader2 = _interopRequireDefault(_jsxLoader);

var _isomorphicMergePlugin = require('./isomorphic-merge-plugin');

var _isomorphicMergePlugin2 = _interopRequireDefault(_isomorphicMergePlugin);

var _isomorpicTools = require('../webpack/isomorpic-tools');

var _isomorpicTools2 = _interopRequireDefault(_isomorpicTools);

var _renameKey = require('../../utils/rename-key');

var _renameKey2 = _interopRequireDefault(_renameKey);

var _runParentFn = require('../../utils/run-parent-fn');

var _runParentFn2 = _interopRequireDefault(_runParentFn);

var _runCustomTask = require('../../utils/run-custom-task');

var _runCustomTask2 = _interopRequireDefault(_runCustomTask);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }

module.exports = exports['default'];