function browserSyncInit(): browserSync.BrowserSyncInstance {
    var browser = browserSync.create();
    browser.init();
    console.log(browser.name);
    console.log(browserSync.name);
    return browser;
}

export = () => {
  let coverageFolder = Config.COVERAGE_DIR;
  let watchedFiles: string[] = [join(coverageFolder, '**')];

  // Serve files from the coverage of this project
  browserSync.create().init({
    server: {
      baseDir: './' + coverageFolder
    },
    port: Config.COVERAGE_PORT,
    files: watchedFiles
  });
};

 done => {
   browserSyncServer = browserSync.create();
   browserSyncServer.init({
     online: false,
     open: false,
     port: 9000,
     logLevel: 'silent',
     proxy: {
       target: 'localhost:3000',
       middleware: [function (req, res, next) { //TODO: historyApiFallback(), 
         res.setHeader('Access-Control-Allow-Origin', '*');
         next();
       }]
     }
   }, function (err, bs) {
     let urls = bs.options.get('urls').toJS();
     console.log(`Application Available At: ${urls.local}`);
     console.log(`BrowserSync Available At: ${urls.ui}`);
     done();
   });
 }

import {
  BrowserSyncInstance,
  create,
} from 'browser-sync';
import { writeFileSync } from 'fs';
import { runner } from 'mocha-headless-chrome';
import { resolve } from 'path';

const uuid = (): string =>
  'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
    const r = Math.random() * 16 | 0, v = c === 'x' ? r : (r & 0x3 | 0x8);
    return v.toString(16);
  });

const browserSync = create();

browserSync.init({
  server: {
    baseDir: './',
    index: 'test/integration/index.html',
  },
  open: false,
  serveStatic: [{
    route: 'resources/rnm.jpg',
    dir: 'test/resources/rnm.jpg',
  }],
}, async (_, browser: BrowserSyncInstance) => {
  const url = browser.getOption('urls').get('local');

  const result = await runner({
    file: url,

export function getBrowserSync (){
    if (bs === null){
        return bs = browserSync.create('Server');
    }
    return browserSync.get('Server');
}

function createServer() {
    const server = browserSync.create('zacher-home-ssr')
    server.init({
        server: path.resolve(__dirname, '..', 'build'),
        ghostMode: false,
        open: false,
    })

    // rebuild and reload on source change
    const srcWatcher = chokidar.watch(srcFolder, {
        ignoreInitial: true,
    })
    function onSourceChange(event : string) {
        return (filename : string) => {
            console.info(`[src][${event}]:`, filename.replace(srcFolder, ''))
            try {
                // use exec to run the build so it's always the latest code
                execSync(`yarn run-script ${scriptsFolder}/buildReact.ts`)
                server.reload(filename)
            } catch (e) {
                console.error(e.message)
            }
        }
    }
    srcWatcher.on('add', onSourceChange('add'))
    srcWatcher.on('change', onSourceChange('change'))

    // rebuild on script change
    const scriptsWatcher = chokidar.watch(scriptsFolder)
    function onScriptChange(fullFilename : string) {
        const filename = fullFilename.replace(scriptsFolder, '')
        const scriptsToRun = scriptFileToCommandMap[filename]
        if (!scriptsToRun) {
            return
        }

        console.info('[script][changed]:', filename)
        try {
            // use exec to run the scripts one by one
            scriptsToRun.forEach(script => execSync(`yarn run-script ${scriptsFolder + script}`))
            // finally, run a fresh build
            execSync(`yarn run-script ${scriptsFolder}/buildReact.ts`)
            server.reload(filename)
        } catch (e) {
            console.error(e.message)
        }
    }
    scriptsWatcher.on('change', onScriptChange)

    // rebuild on sprite change
    const spritesWatcher = chokidar.watch(spritesFolder)
    function onSpriteChange(fullFilename : string) {
        const filename = fullFilename.replace(spritesFolder, '')

        console.info('[sprite][changed]:', filename)
        try {
            // use exec to run the build
            execSync(`yarn run-script ${scriptsFolder}/sprites.ts`)
            execSync(`yarn run-script ${scriptsFolder}/buildReact.ts`)
            server.reload(filename)
        } catch (e) {
            console.error(e.message)
        }
    }
    spritesWatcher.on('change', onSpriteChange)
}

browserSync(config, function (err, bs) {
    console.log(browserSync.active); // true
});

var evt = browserSync.emitter;

evt.on("init", function () {
    console.log("BrowserSync is running!");
});

browserSync(config);

var has = browserSync.has("My server");

var bs = browserSync.create();

bs.init({
    server: "./app"
});

bs.reload();

function browserSyncInit(): browserSync.BrowserSyncInstance {
    var browser = browserSync.create();
    browser.init();
    console.log(browser.name);
    console.log(browserSync.name);
    return browser;
}
var browser = browserSyncInit();

import gulp from "gulp";
import cp from "child_process";
import gutil from "gulp-util";
import BrowserSync from "browser-sync";
import fs from 'fs-extra';

declare function require(path: string): any;

// import image processing tasks
require('./image_tasks');

// // import search index tasks
// require('hugo-search-index/gulp')(gulp, gutil)

const browserSync = BrowserSync.create();
const hugoBin = "hugo";
const defaultArgs = ["-v"];

/**
 * hugo: runs the hugo binary to build the hugo site.
 *  
 * depends -
 *   css : builds sass & minifies css files, placing the result in static/css/ for hugo to pick it up
 *   js  : builds javascript and bundles it with webpack, placing the bundle in static/js/ for hugo to pick it up
 *   img: the img task processes images in-place in static/images/, 
 *        so it must finish before running hugo.
 */
export const hugo = gulp.series('img', buildHugo);

function buildHugo(cb, options?) {
  const args = options ? defaultArgs.concat(options) : defaultArgs;

import * as gulpHelp from 'gulp-help';
import * as util from 'gulp-util';
import * as browserSync from 'browser-sync';
import * as configuration from './tools/config';
import * as gulpLoadPlugins from 'gulp-load-plugins';

const plugins = gulpLoadPlugins({camelize: true});
const CacheBuster = require('gulp-cachebust');
const del = require('del');

global.tools = {};

global.tools.gulp = gulpHelp(gulp, {description: '', hideEmpty: true});
global.tools.plugin = plugins;
global.tools.prod = false;
global.tools.mocks = util.env.mocks;
global.tools.config = configuration.config;
global.tools.bs = browserSync.create();
global.tools.cachebust = new CacheBuster();
global.tools.del = del;
global.tools.timestamp = Math.round(Date.now()/1000);

//Register tasks from tasks folder
const tasks:string[] = readdirSync('./tools/tasks/').filter((task) => {
    //filter just ts files
    return task.indexOf('.ts') !== -1;
});

tasks.forEach((task) => {
    require('./tools/tasks/' + task);
});

import chalk = require ('chalk');
import ncp = require ('ncp');
import Promise = require ('bluebird');
var Table = require ('cli-table');

import BShandler = require ('./browser-sync-handler');
import ChromeTesterClient = require ('./tester/chrome-tester-client');
import ChromeTesterServer = require ('./tester/chrome-tester-server');
import LeenaConfiguration = require ('./config');
import LeenaContext = require ('./context/context');
import logger = require ('./logger');
import utils = require ('./utils');


// Global variables for 'browser-sync' watcher and web server
var bsWatcher : any   = browserSync.create ('Watcher');
var bsWebServer : any = browserSync.create ('Web Server');

export
function initialize (pathConfigFile : string, smtSolver : string) : void {
  // JSON object for the configuration file
  var JSONcontent;

  // Content of the configuration file
  var contentFile : string;

  // Istance of LeenaConfiguration
  var leenaConfig;

  // Array of errors that can be occurred during
  // the parsing of the 'JSONcontent', errors = 0 --> no errors during parsing