ream/dist/export.js

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.exportSite = void 0;
const path_1 = __importDefault(require("path"));
const fs_extra_1 = __importDefault(require("fs-extra"));
const consola_1 = __importDefault(require("consola"));
const chalk_1 = __importDefault(require("chalk"));
const server_1 = require("@ream/server");
const promise_queue_1 = require("@egoist/promise-queue");
const flatten_routes_1 = require("./utils/flatten-routes");
function getHref(attrs) {
    const match = /href\s*=\s*(?:"(.*?)"|'(.*?)'|([^\s>]*))/.exec(attrs);
    return match && (match[1] || match[2] || match[3]);
}
const exportSite = async (dotReamDir, fullyExport) => {
    const ssrManifest = require(path_1.default.join(dotReamDir, 'manifest/ssr-manifest.json'));
    const serverEntry = require(path_1.default.join(dotReamDir, 'server/server-entry.js')).default;
    const globalPreload = await serverEntry.getGlobalPreload();
    // Adding a global `preload` function in `_app.vue` will disable automatic static generation
    if (globalPreload && !fullyExport)
        return;
    const { scripts, styles } = server_1.extractClientManifest(dotReamDir) || {
        scripts: '',
        styles: '',
    };
    const assets = { cssLinkTags: styles, scriptTags: scripts };
    const clientRoutes = await flatten_routes_1.flattenRoutes(serverEntry.clientRoutes);
    const staticPaths = [];
    const exportInfo = { staticPaths, fallbackPathsRaw: [] };
    await Promise.all(clientRoutes.map(async (route) => {
        const shouldExport = route.matched.every((m) => !m.preload);
        if (!shouldExport) {
            return;
        }
        if (route.path === '/:404(.*)') {
            staticPaths.push('/404.html');
        }
        else if (route.path.includes(':')) {
            const paths = [];
            let fallback = false;
            for (const m of route.matched) {
                if (m.getStaticPaths) {
                    const res = await m.getStaticPaths();
                    paths.push(...res.paths);
                    if (res.fallback != null) {
                        fallback = res.fallback;
                    }
                }
            }
            if (paths.length === 0) {
                consola_1.default.warn(`No static paths provided for ${route.path}, skipped exporting`);
            }
            for (const path of paths) {
                const staticPath = route.path
                    .replace('(.*)', '')
                    .replace(/:([^\/]+)/g, (_, p1) => path.params[p1]);
                staticPaths.push(staticPath);
            }
            if (fallback) {
                exportInfo.fallbackPathsRaw.push(route.path);
            }
        }
        else {
            staticPaths.push(route.path);
        }
    }));
    await fs_extra_1.default.outputFile(path_1.default.join(dotReamDir, 'meta/export-info.json'), JSON.stringify(exportInfo), 'utf8');
    const queue = new promise_queue_1.PromiseQueue(async (jobId, url) => {
        consola_1.default.info(chalk_1.default.dim(jobId));
        const result = await server_1.render({
            url,
            dotReamDir,
            ssrManifest,
            serverEntry,
            assets,
            exportInfo: {
                staticPaths: [],
                // Skip fallback check, force all static paths to render
                fallbackPathsRaw: clientRoutes.map((r) => r.path),
            },
        });
        // Crawl pages
        if (fullyExport) {
            for (const file of result.cacheFiles.keys()) {
                if (file.endsWith('.html')) {
                    const html = result.cacheFiles.get(file);
                    if (html) {
                        // find all `<a>` tags in exported html files and export links that are not yet exported
                        let match = null;
                        const LINK_RE = /<a ([\s\S]+?)>/gm;
                        while ((match = LINK_RE.exec(html))) {
                            const href = getHref(match[1]);
                            if (href) {
                                const url = new URL(href, 'http://self');
                                if (url.host === 'self') {
                                    queue.add(`Exporting ${url.pathname}`, url.pathname);
                                }
                            }
                        }
                    }
                }
            }
        }
        await server_1.writeCacheFiles(result.cacheFiles);
    }, { maxConcurrent: 100 });
    for (const path of staticPaths) {
        queue.add(`Exporting ${path}`, path);
    }
    await queue.run();
    consola_1.default.success(`Your app has been exported to ${path_1.default.relative(process.cwd(), path_1.default.join(dotReamDir, 'client'))}`);
};
exports.exportSite = exportSite;