@patternplate/compiler/lib/compiler.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const cascade_resolve_1 = require("./cascade-resolve");
const webpack_entry_1 = require("@patternplate/webpack-entry");
const webpack = require("webpack");
const resolveFrom = require("resolve-from");
const MemoryFS = require("memory-fs");
const nodeExternals = require("webpack-node-externals");
const resolve = (resolveFrom.silent || resolveFrom);
function compiler(options) {
    return __awaiter(this, void 0, void 0, function* () {
        const TO_STRING_LOADER = resolve(__dirname, "to-string-loader");
        const CSS_LOADER = resolve(__dirname, "css-loader");
        const HTML_LOADER = resolve(__dirname, "html-loader");
        const COVER = resolve(__dirname, "@patternplate/cover-client");
        const DEMO = resolve(__dirname, "@patternplate/demo-client");
        const PROBE = resolve(__dirname, "@patternplate/probe-client");
        const fs = new MemoryFS();
        const { config, cwd } = options;
        const components = yield webpack_entry_1.webpackEntry(config.entry, { cwd });
        const bases = [cwd, process.cwd()].filter(Boolean);
        const render = cascade_resolve_1.cascadeResolve(config.render, { bases, cwd });
        const mount = cascade_resolve_1.cascadeResolve(config.mount, { bases, cwd });
        const entry = options.target === "node"
            ? { components, render }
            : {
                components,
                "cover-client": COVER,
                demo: DEMO,
                mount: mount,
                probe: PROBE
            };
        if (typeof config.cover === "string") {
            entry.cover = cascade_resolve_1.cascadeResolve(config.cover, { bases, cwd });
        }
        const compiler = webpack({
            entry,
            target: options.target,
            externals: options.target === "node" ? [nodeExternals()] : [],
            mode: "development",
            module: {
                rules: [
                    {
                        test: /\.css$/,
                        use: [TO_STRING_LOADER, CSS_LOADER]
                    },
                    {
                        test: /\.html$/,
                        use: [HTML_LOADER]
                    }
                ]
            },
            output: {
                library: "patternplate-[name]",
                libraryTarget: options.target === "node" ? "commonjs2" : "window",
                path: "/",
                filename: `patternplate.${options.target}.[name].js`
            }
        });
        compiler.outputFileSystem = fs;
        return compiler;
    });
}
exports.compiler = compiler;
exports.default = compiler;
//# sourceMappingURL=compiler.js.map