jspm-devtools/dist/index.js

Make development great again!

'use strict';

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

var _chokidar = require('chokidar');

var _chokidar2 = _interopRequireDefault(_chokidar);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _fs = require('fs');

var _fs2 = _interopRequireDefault(_fs);

var _jspm = require('jspm');

var _jspm2 = _interopRequireDefault(_jspm);

var _socket = require('socket.io');

var _socket2 = _interopRequireDefault(_socket);

var _spdy = require('spdy');

var _spdy2 = _interopRequireDefault(_spdy);

var _handlers = require('./handlers');

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

var setupHMR = function setupHMR(tools) {
    if (tools.hmr) {
        (function () {

            var cssFiles = new Set();

            tools.entries.forEach(function (entry) {
                return tools._thenBuild(tools.builder.trace(entry).then(function (m) {
                    Object.keys(m).filter(function (file) {
                        return file.endsWith('.pcss');
                    }).forEach(function (f) {
                        return cssFiles.add(f);
                    });
                }));
            });

            var socket = tools.socket;

            /**
             * When a new client connects add it to a list and handle it disconnecting
             */
            socket.on('connect', function (soc) {
                soc.on('identification', function (name) {
                    console.log('connected client: ', name);
                });
            });

            tools.watcher.on('all', function (event, changePath) {
                changePath = _path2.default.relative(tools._baseURL, changePath);
                console.log('File ', changePath, ' emitted: ', event);
                var absolutePath = _path2.default.join(process.cwd(), changePath);

                /**
                 * Deal with the special case when the changed file is a scss file
                 * due to the face that we compile it as a whole.
                 */
                if (changePath.endsWith('.pcss')) {
                    console.log(Object.keys(tools.builder.cache.trace).filter(function (f) {
                        return f.endsWith('.pcss');
                    }));
                    cssFiles.add(changePath);
                    console.log(tools.builder.invalidate(changePath));
                    cssFiles.forEach(function (file) {
                        socket.emit(event, { path: file, file: file });
                    });
                } else {
                    socket.emit(event, { path: changePath, absolutePath: absolutePath });
                }
            });
        })();
    }
}; /**
    * Created by alexisvincent on 2016/09/02.
    */


var optionsValid = function optionsValid() {
    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};


    var valid = true;
    var error = function error(msg) {
        console.error(msg);
        valid = false;
    };

    if (options.packagePath) try {
        _fs2.default.statSync(options.packagePath);
    } catch (e) {
        if (options.packagePath == '') error('\nJSPM Devtools:\n        \n        You did not provide a valid packagePath\n\n');
    }

    return valid;
};

var make = function make(options) {

    // Validate options
    if (!optionsValid(options)) throw new Error();

    var optionDefaults = {
        entries: [],
        packagePath: process.cwd(),
        hmr: false, // Since hmr needs socket.io default to it off
        resolveHandler: function resolveHandler(_ref) {
            var resolvers = _ref.resolvers;
            var initiatedBySystemJS = _ref.initiatedBySystemJS;
            return initiatedBySystemJS ? resolvers.bundle() : resolvers.next();
        },
        port: 1337
    };

    var buildOptionDefaults = {
        sourceMaps: 'inline'
    };

    // Construct tools object from defaults and provided options
    var tools = Object.assign({}, optionDefaults, options);

    // Construct builder config from defaults and provided options
    tools.builderConfig = Object.assign({}, buildOptionDefaults, tools.builderConfig);

    // If no jspm instance was specified, set the default
    if (!tools.jspm) {
        _jspm2.default.setPackagePath(tools.packagePath);
        tools.jspm = _jspm2.default;
    }

    // Construct for pipelining build operations (parallel is slower)
    tools._buildPromise = Promise.resolve();
    tools._thenBuild = function (f) {
        tools._buildPromise = tools._buildPromise.then(f);
    };

    // Builder instance (so we can share the cache)
    tools.builder = new tools.jspm.Builder();

    tools._loaderConfig = tools.builder.loader.getConfig();

    tools._baseURL = tools.packagePath + _path2.default.relative(tools.packagePath, tools._loaderConfig.baseURL.substr(7));

    // Watch for changes (used to invalidate builder and hmr)
    tools.watcher = _chokidar2.default.watch(tools._baseURL, {
        ignored: ["**/jspm_packages", "**/node_modules", "**/icons"],
        ignoreInitial: true
    });

    // Invalidate builder when anything happens to a file (imprecise)
    tools.watcher.on('all', function (event, changePath) {
        tools.builder.invalidate(changePath);
    });

    // Preemptively trace the entry and bundle (populate trace/compile cache)
    tools.entries.forEach(function (entry) {
        return tools._thenBuild(tools.builder.bundle(entry, tools.builderConfig).then(function () {
            console.log(":: Preemptively Cached ", entry);
        }));
    });

    // Express handler
    tools.handler = (0, _handlers.handler)(tools);

    tools.server = _spdy2.default.createServer(require('spdy-keys'), function () {
        return "Nothing to see here";
    });
    tools.socket = (0, _socket2.default)(tools.server);

    tools.server.listen(tools.port || 1337);

    // Setup HMR
    setupHMR(tools);

    return tools;
};

exports.make = make;