build-boiler/gulp/tasks/browser-sync.js

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

'use strict';

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

exports.default = function (gulp, plugins, config) {
  var _arguments = arguments;
  var browserSync = plugins.browserSync;
  var bsParent = config.browserSync;
  var sources = config.sources;
  var utils = config.utils;
  var parentMiddleware = bsParent.middleware;
  var parentOpenFn = bsParent.open;
  var internalHost = sources.internalHost;
  var devPort = sources.devPort;
  var buildDir = sources.buildDir;
  var addbase = utils.addbase;
  var logError = utils.logError;

  var baseOpen = 'http://' + internalHost + ':' + devPort;
  var openPath = baseOpen;
  var shouldOpen = true;

  if (_lodash2.default.isFunction(parentOpenFn)) {
    openPath = (0, _callAndReturn2.default)(config)(parentOpenFn, baseOpen);
  } else if (_lodash2.default.isBoolean(parentOpenFn)) {
    shouldOpen = parentOpenFn;
  }

  var expireHeaders = function expireHeaders(req, res, next) {
    res.setHeader('cache-control', 'public, max-age=0');
    next();
  };

  var defaultMiddleware = [function (req, res, next) {
    res.setHeader('Access-Control-Allow-Origin', '*');
    res.setHeader('Access-Control-Allow-Methods', 'POST, GET, OPTIONS');
    res.setHeader('Access-Control-Allow-Headers', 'authorization, accept');
    res.setHeader('Access-Control-Max-Age', '1728000');
    if (req.method === 'OPTIONS') {
      res.end();
    } else {
      next();
    }
  }, expireHeaders];

  var middleware = _lodash2.default.isFunction(parentMiddleware) ? parentMiddleware(config, defaultMiddleware) : defaultMiddleware;

  if (_lodash2.default.isUndefined(middleware)) {
    logError({
      err: new Error('You must `return` a middleware Function or Array'),
      plugin: '[browser-sync: middleware]'
    });
  }

  return function (cb) {
    var bsConfig = {
      open: false,
      port: devPort,
      server: {
        baseDir: addbase(buildDir),
        middleware: middleware
      }
    };

    var parentConfig = (0, _runParentFn2.default)(_arguments, {
      data: bsConfig
    });

    var _parentConfig$data = parentConfig.data;
    var data = _parentConfig$data === undefined ? {} : _parentConfig$data;
    var fn = parentConfig.fn;


    var task = function task(done) {
      browserSync(data, function () {
        if (shouldOpen) {
          (0, _open2.default)(openPath);
        }

        done();
      });
    };

    return (0, _runCustomTask2.default)(task, fn, cb);
  };
};

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _open = require('open');

var _open2 = _interopRequireDefault(_open);

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

var _runParentFn2 = _interopRequireDefault(_runParentFn);

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

var _runCustomTask2 = _interopRequireDefault(_runCustomTask);

var _callAndReturn = require('../utils/call-and-return');

var _callAndReturn2 = _interopRequireDefault(_callAndReturn);

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

module.exports = exports['default'];