ream/dist/index.js

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __exportStar = (this && this.__exportStar) || function(m, exports) {
    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Ream = void 0;
const path_1 = require("path");
const resolve_from_1 = __importDefault(require("resolve-from"));
const load_config_1 = require("./utils/load-config");
const load_plugins_1 = require("./load-plugins");
const store_1 = require("./store");
const http_1 = require("http");
const fs_extra_1 = require("fs-extra");
const constants_1 = require("./utils/constants");
class Ream {
    constructor(options = {}, configOverride = {}) {
        this.rootDir = path_1.resolve(options.rootDir || '.');
        if (options.srcDir) {
            this.srcDir = path_1.join(this.rootDir, options.srcDir);
        }
        else {
            const hasPagesInSrc = fs_extra_1.existsSync(path_1.join(this.rootDir, 'src/pages'));
            this.srcDir = hasPagesInSrc ? path_1.join(this.rootDir, 'src') : this.rootDir;
        }
        this.isDev = Boolean(options.dev);
        if (!process.env.NODE_ENV) {
            process.env.NODE_ENV = this.isDev ? 'development' : 'production';
        }
        this.store = store_1.store;
        const { data: projectConfig = {}, path: configPath } = load_config_1.loadConfig(this.rootDir);
        this.configPath = configPath;
        this.config = {
            ...projectConfig,
            env: {
                ...projectConfig.env,
                ...configOverride.env,
            },
            plugins: [
                ...(configOverride.plugins || []),
                ...(projectConfig.plugins || []),
            ],
            imports: projectConfig.imports || [],
            server: {
                ...projectConfig.server,
            },
        };
        process.env.PORT = String(this.config.server.port);
    }
    resolveRootDir(...args) {
        return path_1.resolve(this.rootDir, ...args);
    }
    resolveSrcDir(...args) {
        return path_1.resolve(this.srcDir, ...args);
    }
    resolveDotReam(...args) {
        return this.resolveRootDir('.ream', ...args);
    }
    resolveOwnDir(...args) {
        return path_1.resolve(constants_1.OWN_DIR, ...args);
    }
    resolveInPackage(pkg, target) {
        const pkgDir = path_1.dirname(resolve_from_1.default(process.cwd(), `${pkg}/package.json`));
        return resolve_from_1.default(pkgDir, target);
    }
    async prepare({ shouldCleanDir, shouldPrepreFiles, }) {
        await load_plugins_1.loadPlugins(this);
        if (shouldCleanDir) {
            // Remove everything but cache
            await Promise.all(['templates', 'manifest', 'server', 'client', 'export'].map((name) => {
                return fs_extra_1.remove(this.resolveDotReam(name));
            }));
        }
        // Preparing for webpack build process
        if (shouldPrepreFiles) {
            console.log('Preparing Ream files');
            const { prepareFiles } = await Promise.resolve().then(() => __importStar(require('./prepare-files')));
            await prepareFiles(this);
        }
    }
    localResolve(name) {
        return resolve_from_1.default.silent(this.rootDir, name);
    }
    localRequire(name) {
        const path = this.localResolve(name);
        return path && require(path);
    }
    async getRequestHandler() {
        await this.prepare({
            shouldCleanDir: this.isDev,
            shouldPrepreFiles: this.isDev,
        });
        const { createServer } = await Promise.resolve().then(() => __importStar(require('./server')));
        const server = await createServer(this);
        return server;
    }
    async serve() {
        const handler = await this.getRequestHandler();
        const server = http_1.createServer(handler);
        const port = this.config.server.port || 3000;
        server.listen(port);
        console.log(`> http://localhost:${port}`);
        return server;
    }
    async build(fullyExport) {
        await this.prepare({ shouldCleanDir: true, shouldPrepreFiles: true });
        const { build } = await Promise.resolve().then(() => __importStar(require('./build')));
        await build(this);
        // Export static pages
        const { exportSite } = await Promise.resolve().then(() => __importStar(require('./export')));
        await exportSite(this.resolveDotReam(), fullyExport);
    }
}
exports.Ream = Ream;
__exportStar(require("./types"), exports);