varan/dist/lib/buildAndRunDevServer.js

A webpack starter kit for offline-first bring-your-own-code apps with server side rendering

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const lodash_1 = require("lodash");
const webpack_1 = __importDefault(require("webpack"));
const webpack_dev_server_1 = __importDefault(require("webpack-dev-server"));
const BuildError_1 = __importDefault(require("./BuildError"));
// eslint-disable-next-line @typescript-eslint/no-var-requires
const pkg = require('../../package.json');
// Init
const getOpts = (options) => lodash_1.defaults({}, options, {
    waitForPromise: null,
    devServerProxy: false,
    openBrowser: false,
    devServerWSPort: 3002,
});
// Exports
async function buildAndRunDevServer(config, host, port, options) {
    const opts = getOpts(options);
    const compiler = webpack_1.default(config);
    if (opts.inputFileSystem)
        compiler.inputFileSystem = opts.inputFileSystem;
    if (opts.outputFileSystem)
        compiler.outputFileSystem = opts.outputFileSystem;
    // Use webpack-dev-server ?
    if (config.devServer) {
        return new Promise((resolve, reject) => {
            let initialBuild = true;
            const devServerConfig = Object.assign(Object.assign({ host,
                port }, config.devServer), { proxy: (opts.devServerProxy && config.devServer && config.devServer.proxy) || undefined, open: opts.openBrowser });
            // Add wait for promise middleware?
            if (opts.waitForPromise) {
                devServerConfig.before = function devServerBefore(app, server, devServerCompiler) {
                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                    app.use((req, res, next) => opts.waitForPromise.then(next));
                    if (config.devServer && config.devServer.before)
                        config.devServer.before(app, server, devServerCompiler);
                };
            }
            const devServer = new webpack_dev_server_1.default(compiler, devServerConfig);
            devServer.waitForPromise = opts.waitForPromise;
            devServer.listen(port, host, (err) => {
                if (err)
                    reject(err);
            });
            compiler.hooks.done.tap(pkg.name, (stats) => {
                if (initialBuild) {
                    initialBuild = false;
                    resolve({
                        compiler,
                        stats,
                        runner: devServer,
                        errors: [],
                        warnings: [],
                    });
                }
            });
        });
    }
    return new Promise((resolve, reject) => compiler.run((err, stats) => {
        if (err)
            return reject(err);
        const out = {
            compiler,
            stats,
            runner: null,
            errors: [],
            warnings: [],
        };
        const info = stats.toJson();
        out.errors = info.errors;
        out.warnings = info.warnings;
        if (stats.hasErrors() || info.errors.length > 0) {
            const buildError = new BuildError_1.default('Build failed with errors');
            buildError.errors = out.errors;
            buildError.warnings = out.warnings;
            return reject(buildError);
        }
        return resolve(out);
    }));
}
exports.default = buildAndRunDevServer;
//# sourceMappingURL=buildAndRunDevServer.js.map