vike 0.4.220 → 0.4.221-commit-8577456

package/dist/cjs/node/prerender/runPrerender.js

@@ -51,7 +51,6 @@ const vite_1 = require("vite");
 const getPageFiles_js_1 = require("../../shared/getPageFiles.js");
 const getPageContextRequestUrl_js_1 = require("../../shared/getPageContextRequestUrl.js");
 const resolveRouteString_js_1 = require("../../shared/route/resolveRouteString.js");
-const helpers_js_1 = require("../../shared/page-configs/helpers.js");
 const getConfigValueRuntime_js_1 = require("../../shared/page-configs/getConfigValueRuntime.js");
 const loadConfigValues_js_1 = require("../../shared/page-configs/loadConfigValues.js");
 const error_page_js_1 = require("../../shared/error-page.js");
@@ -63,8 +62,12 @@ const noRouteMatch_js_1 = require("../../shared/route/noRouteMatch.js");
 const getVikeConfig_js_1 = require("../plugin/plugins/importUserCode/v1-design/getVikeConfig.js");
 const logErrorHint_js_1 = require("../runtime/renderPage/logErrorHint.js");
 const executeHook_js_1 = require("../../shared/hooks/executeHook.js");
-const getConfigValueBuildTime_js_1 = require("../../shared/page-configs/getConfigValueBuildTime.js");
 const prepareViteApiCall_js_1 = require("../api/prepareViteApiCall.js");
+const context_js_1 = require("./context.js");
+const resolvePrerenderConfig_js_1 = require("./resolvePrerenderConfig.js");
+const getOutDirs_js_1 = require("../plugin/shared/getOutDirs.js");
+const context_js_2 = require("../cli/context.js");
+const isViteCliCall_js_1 = require("../plugin/shared/isViteCliCall.js");
 async function runPrerenderFromAPI(options = {}) {
     return await runPrerender(options, 'prerender()');
     // - We purposely propagate the error to the user land, so that the error interrupts the user land. It's also, I guess, a nice-to-have that the user has control over the error.
@@ -82,18 +85,25 @@ async function runPrerenderFromCLIPrerenderCommand() {
         process.exit(1);
     }
     runPrerender_forceExit();
+    (0, utils_js_1.assert)(false);
 }
-async function runPrerenderFromAutoRun(viteConfig) {
+async function runPrerenderFromAutoRun(viteConfig, config) {
+    let prerenderContextPublic;
     try {
-        await runPrerender({ viteConfig });
+        const ret = await runPrerender({ viteConfig });
+        prerenderContextPublic = ret.prerenderContextPublic;
     }
     catch (err) {
         console.error(err);
         (0, logErrorHint_js_1.logErrorHint)(err);
         process.exit(1);
     }
+    config.vike.prerenderContext = prerenderContextPublic;
+    const forceExit = (0, context_js_2.isVikeCli)() || (0, isViteCliCall_js_1.isViteCliCall)();
+    return { forceExit };
 }
 async function runPrerender(options = {}, standaloneTrigger) {
+    (0, context_js_1.setContextIsPrerendering)();
     checkOutdatedOptions(options);
     (0, utils_js_1.onSetupPrerender)();
     (0, globalContext_js_1.setGlobalContext_isPrerendering)();
@@ -105,9 +115,9 @@ async function runPrerender(options = {}, standaloneTrigger) {
     await disableReactStreaming();
     const viteConfig = await (0, vite_1.resolveConfig)(options.viteConfig || {}, 'build', 'production');
     const vikeConfig = await (0, getVikeConfig_js_1.getVikeConfig)(viteConfig);
-    const { outDirClient } = (0, utils_js_1.getOutDirs)(viteConfig);
+    const { outDirClient } = (0, getOutDirs_js_1.getOutDirs)(viteConfig);
     const { root } = viteConfig;
-    const prerenderConfig = vikeConfig.vikeConfigGlobal.prerender;
+    const prerenderConfig = (0, resolvePrerenderConfig_js_1.resolvePrerenderConfig)(vikeConfig);
     validatePrerenderConfig(prerenderConfig);
     if (!prerenderConfig) {
         (0, utils_js_1.assert)(standaloneTrigger);
@@ -118,46 +128,47 @@ async function runPrerender(options = {}, standaloneTrigger) {
     const { partial = false, noExtraDir = false, parallel = true } = prerenderConfig || {};
     const concurrencyLimit = (0, utils_js_1.pLimit)(parallel === false || parallel === 0 ? 1 : parallel === true || parallel === undefined ? (0, os_1.cpus)().length : parallel);
     await (0, globalContext_js_1.initGlobalContext_runPrerender)();
-    const globalContext = (0, globalContext_js_1.getGlobalContext)();
+    const globalContext = await (0, globalContext_js_1.getGlobalContextInternal)();
     globalContext.pageFilesAll.forEach(assertExportNames);
-    const prerenderContext = {};
-    (0, utils_js_1.objectAssign)(prerenderContext, {
-        _urlHandler: null,
-        _noExtraDir: noExtraDir ?? false,
+    const prerenderContext = {
+        noExtraDir: noExtraDir ?? false,
         pageContexts: [],
-        pageContextInit: options.pageContextInit ?? null
-    });
+        pageContextInit: options.pageContextInit ?? null,
+        prerenderedPageContexts: {},
+        output: []
+    };
     const doNotPrerenderList = [];
-    await collectDoNoPrerenderList(vikeConfig.pageConfigs, doNotPrerenderList, concurrencyLimit);
-    await callOnBeforePrerenderStartHooks(prerenderContext, concurrencyLimit, doNotPrerenderList);
-    await handlePagesWithStaticRoutes(prerenderContext, doNotPrerenderList, concurrencyLimit);
-    await callOnPrerenderStartHook(prerenderContext);
-    const prerenderedPageContexts = {};
+    await collectDoNoPrerenderList(vikeConfig.pageConfigs, doNotPrerenderList, concurrencyLimit, globalContext);
+    await callOnBeforePrerenderStartHooks(prerenderContext, globalContext, concurrencyLimit, doNotPrerenderList);
+    await handlePagesWithStaticRoutes(prerenderContext, globalContext, doNotPrerenderList, concurrencyLimit);
+    await callOnPrerenderStartHook(prerenderContext, globalContext);
     let prerenderedCount = 0;
+    // Write files as soon as pages finish rendering (instead of writing all files at once only after all pages have rendered).
     const onComplete = async (htmlFile) => {
         prerenderedCount++;
         if (htmlFile.pageId) {
-            prerenderedPageContexts[htmlFile.pageId] = htmlFile.pageContext;
+            prerenderContext.prerenderedPageContexts[htmlFile.pageId] = htmlFile.pageContext;
         }
-        await writeFiles(htmlFile, root, outDirClient, options.onPagePrerender, logLevel);
+        await writeFiles(htmlFile, root, outDirClient, options.onPagePrerender, prerenderContext.output, logLevel);
     };
-    await routeAndPrerender(prerenderContext, concurrencyLimit, onComplete);
-    warnContradictoryNoPrerenderList(prerenderedPageContexts, doNotPrerenderList);
-    await prerender404(prerenderedPageContexts, prerenderContext, onComplete);
+    await routeAndPrerender(prerenderContext, globalContext, concurrencyLimit, onComplete);
+    warnContradictoryNoPrerenderList(prerenderContext.prerenderedPageContexts, doNotPrerenderList);
+    await prerender404(prerenderContext, globalContext, onComplete);
     if (logLevel === 'info') {
         console.log(`${picocolors_1.default.green(`✓`)} ${prerenderedCount} HTML documents pre-rendered.`);
     }
-    warnMissingPages(prerenderedPageContexts, doNotPrerenderList, partial);
-    return { viteConfig };
+    await warnMissingPages(prerenderContext.prerenderedPageContexts, globalContext, doNotPrerenderList, partial);
+    const prerenderContextPublic = makePublic(prerenderContext);
+    return { viteConfig, prerenderContextPublic };
 }
-async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, concurrencyLimit) {
+async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, concurrencyLimit, globalContext) {
     // V1 design
     pageConfigs.forEach((pageConfig) => {
-        const configName = 'prerender';
-        const configValue = (0, getConfigValueBuildTime_js_1.getConfigValueBuildTime)(pageConfig, configName, 'boolean');
-        if (configValue?.value === false) {
-            const configValueFilePathToShowToUser = (0, helpers_js_1.getConfigValueFilePathToShowToUser)(configValue.definedAtData);
-            (0, utils_js_1.assert)(configValueFilePathToShowToUser);
+        const configValue = (0, resolvePrerenderConfig_js_1.resolvePrerenderConfigLocal)(pageConfig);
+        if (!configValue)
+            return;
+        const { value, configValueFilePathToShowToUser } = configValue;
+        if (value === false) {
             doNotPrerenderList.push({
                 pageId: pageConfig.pageId,
                 setByConfigName: 'prerender',
@@ -168,7 +179,6 @@ async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, concurr
     });
     // Old design
     // TODO/v1-release: remove
-    const globalContext = (0, globalContext_js_1.getGlobalContext)();
     await Promise.all(globalContext.pageFilesAll
         .filter((p) => {
         assertExportNames(p);
@@ -211,9 +221,8 @@ function assertExportNames(pageFile) {
     const { exportNames, fileType } = pageFile;
     (0, utils_js_1.assert)(exportNames || fileType === '.page.route' || fileType === '.css', pageFile.filePath);
 }
-async function callOnBeforePrerenderStartHooks(prerenderContext, concurrencyLimit, doNotPrerenderList) {
+async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext, concurrencyLimit, doNotPrerenderList) {
     const onBeforePrerenderStartHooks = [];
-    const globalContext = (0, globalContext_js_1.getGlobalContext)();
     // V1 design
     await Promise.all(globalContext.pageConfigs.map((pageConfig) => concurrencyLimit(async () => {
         const hookName = 'onBeforePrerenderStart';
@@ -261,7 +270,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, concurrencyLimi
         }
         const prerenderResult = await (0, executeHook_js_1.executeHook)(() => hookFn(), { hookName, hookFilePath, hookTimeout }, null);
         const result = normalizeOnPrerenderHookResult(prerenderResult, hookFilePath, hookName);
-        result.forEach(({ url, pageContext }) => {
+        await Promise.all(result.map(async ({ url, pageContext }) => {
             {
                 const pageContextFound = prerenderContext.pageContexts.find((pageContext) => isSameUrl(pageContext.urlOriginal, url));
                 if (pageContextFound) {
@@ -272,7 +281,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, concurrencyLimi
                     (0, utils_js_1.assertUsage)(false, `URL ${picocolors_1.default.cyan(url)} provided ${providedTwice}. Make sure to provide the URL only once instead.`);
                 }
             }
-            const pageContextNew = createPageContext(url, prerenderContext);
+            const pageContextNew = await createPageContext(url, prerenderContext, globalContext);
             (0, utils_js_1.objectAssign)(pageContextNew, {
                 _providedByHook: {
                     hookFilePath,
@@ -286,12 +295,11 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, concurrencyLimi
                 });
                 (0, utils_js_1.objectAssign)(pageContextNew, pageContext);
             }
-        });
+        }));
     })));
 }
-async function handlePagesWithStaticRoutes(prerenderContext, doNotPrerenderList, concurrencyLimit) {
+async function handlePagesWithStaticRoutes(prerenderContext, globalContext, doNotPrerenderList, concurrencyLimit) {
     // Pre-render pages with a static route
-    const globalContext = (0, globalContext_js_1.getGlobalContext)();
     await Promise.all(globalContext.pageRoutes.map((pageRoute) => concurrencyLimit(async () => {
         const { pageId } = pageRoute;
         if (doNotPrerenderList.find((p) => p.pageId === pageId)) {
@@ -317,7 +325,7 @@ async function handlePagesWithStaticRoutes(prerenderContext, doNotPrerenderList,
             return;
         }
         const routeParams = {};
-        const pageContext = createPageContext(urlOriginal, prerenderContext);
+        const pageContext = await createPageContext(urlOriginal, prerenderContext, globalContext);
         (0, utils_js_1.objectAssign)(pageContext, {
             _providedByHook: null,
             routeParams,
@@ -335,11 +343,11 @@ async function handlePagesWithStaticRoutes(prerenderContext, doNotPrerenderList,
         prerenderContext.pageContexts.push(pageContext);
     })));
 }
-function createPageContext(urlOriginal, prerenderContext) {
+async function createPageContext(urlOriginal, prerenderContext, globalContext) {
     const pageContext = {
         _urlHandler: null,
         _urlRewrite: null,
-        _noExtraDir: prerenderContext._noExtraDir,
+        _noExtraDir: prerenderContext.noExtraDir,
         _prerenderContext: prerenderContext
     };
     const pageContextInit = {
@@ -347,13 +355,12 @@ function createPageContext(urlOriginal, prerenderContext) {
     };
     (0, utils_js_1.objectAssign)(pageContextInit, prerenderContext.pageContextInit);
     {
-        const pageContextInitEnhanced = (0, renderPageAlreadyRouted_js_1.getPageContextInitEnhanced)(pageContextInit);
+        const pageContextInitEnhanced = await (0, renderPageAlreadyRouted_js_1.getPageContextInitEnhanced)(pageContextInit, globalContext);
         (0, utils_js_1.objectAssign)(pageContext, pageContextInitEnhanced);
     }
     return pageContext;
 }
-async function callOnPrerenderStartHook(prerenderContext) {
-    const globalContext = (0, globalContext_js_1.getGlobalContext)();
+async function callOnPrerenderStartHook(prerenderContext, globalContext) {
     let onPrerenderStartHook;
     // V1 design
     if (globalContext.pageConfigs.length > 0) {
@@ -425,17 +432,20 @@ async function callOnPrerenderStartHook(prerenderContext) {
     const docLink = 'https://vike.dev/i18n#pre-rendering';
     // Set `enumerable` to `false` to avoid computed URL properties from being iterated & copied in onPrerenderStart() hook, e.g. /examples/i18n/
     const { restoreEnumerable, addPageContextComputedUrl } = makePageContextComputedUrlNonEnumerable(prerenderContext.pageContexts);
-    let result = await (0, executeHook_js_1.executeHook)(() => hookFn({
-        pageContexts: prerenderContext.pageContexts,
+    let result = await (0, executeHook_js_1.executeHook)(() => {
+        const prerenderContextPublic = makePublic(prerenderContext);
         // TODO/v1-release: remove warning
-        get prerenderPageContexts() {
-            (0, utils_js_1.assertWarning)(false, `prerenderPageContexts has been renamed pageContexts, see ${docLink}`, {
-                showStackTrace: true,
-                onlyOnce: true
-            });
-            return prerenderContext.pageContexts;
-        }
-    }), onPrerenderStartHook, null);
+        Object.defineProperty(prerenderContextPublic, 'prerenderPageContexts', {
+            get() {
+                (0, utils_js_1.assertWarning)(false, `prerenderPageContexts has been renamed pageContexts, see ${docLink}`, {
+                    showStackTrace: true,
+                    onlyOnce: true
+                });
+                return prerenderContext.pageContexts;
+            }
+        });
+        return hookFn(prerenderContextPublic);
+    }, onPrerenderStartHook, null);
     restoreEnumerable();
     if (result === null || result === undefined) {
         return;
@@ -477,8 +487,7 @@ async function callOnPrerenderStartHook(prerenderContext) {
     });
     addPageContextComputedUrl(prerenderContext.pageContexts);
 }
-async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete) {
-    const globalContext = (0, globalContext_js_1.getGlobalContext)();
+async function routeAndPrerender(prerenderContext, globalContext, concurrencyLimit, onComplete) {
     (0, utils_js_1.assert)(globalContext.isPrerendering);
     // Route all URLs
     await Promise.all(prerenderContext.pageContexts.map((pageContext) => concurrencyLimit(async () => {
@@ -542,7 +551,7 @@ async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete)
             pageContext,
             htmlString: documentHtml,
             pageContextSerialized,
-            doNotCreateExtraDirectory: prerenderContext._noExtraDir,
+            doNotCreateExtraDirectory: prerenderContext.noExtraDir,
             pageId
         });
     })));
@@ -560,8 +569,7 @@ function warnContradictoryNoPrerenderList(prerenderedPageContexts, doNotPrerende
         (0, utils_js_1.assertWarning)(false, `The ${providedByHook.hookName}() hook defined by ${providedByHook.hookFilePath} returns the URL ${picocolors_1.default.cyan(urlOriginal)}, while ${setByConfigFile} sets the config ${picocolors_1.default.cyan(setByConfigName)} to ${picocolors_1.default.cyan(String(setByConfigValue))}. This is contradictory: either don't set the config ${picocolors_1.default.cyan(setByConfigName)} to ${picocolors_1.default.cyan(String(setByConfigValue))} or remove the URL ${picocolors_1.default.cyan(urlOriginal)} from the list of URLs to be pre-rendered.`, { onlyOnce: true });
     });
 }
-function warnMissingPages(prerenderedPageContexts, doNotPrerenderList, partial) {
-    const globalContext = (0, globalContext_js_1.getGlobalContext)();
+async function warnMissingPages(prerenderedPageContexts, globalContext, doNotPrerenderList, partial) {
     const isV1 = globalContext.pageConfigs.length > 0;
     const hookName = isV1 ? 'onBeforePrerenderStart' : 'prerender';
     /* TODO/after-v1-design-release: document setting `prerender: false` as an alternative to using prerender.partial (both in the warnings and the docs)
@@ -577,11 +585,11 @@ function warnMissingPages(prerenderedPageContexts, doNotPrerenderList, partial)
         (0, utils_js_1.assertWarning)(partial, `Cannot pre-render page ${pageAt} because it has a non-static route, while no ${hookName}() hook returned any URL matching the page's route. You need to use a ${hookName}() hook (https://vike.dev/${hookName}) providing a list of URLs for ${pageAt} that should be pre-rendered. If you don't want to pre-render ${pageAt} then use the option prerender.partial (https://vike.dev/prerender#partial) to suppress this warning.`, { onlyOnce: true });
     });
 }
-async function prerender404(prerenderedPageContexts, prerenderContext, onComplete) {
-    if (!Object.values(prerenderedPageContexts).find(({ urlOriginal }) => urlOriginal === '/404')) {
+async function prerender404(prerenderContext, globalContext, onComplete) {
+    if (!Object.values(prerenderContext.prerenderedPageContexts).find(({ urlOriginal }) => urlOriginal === '/404')) {
         let result;
         try {
-            result = await (0, renderPageAlreadyRouted_js_1.prerender404Page)(prerenderContext.pageContextInit);
+            result = await (0, renderPageAlreadyRouted_js_1.prerender404Page)(prerenderContext.pageContextInit, globalContext);
         }
         catch (err) {
             assertIsNotAbort(err, 'the 404 page');
@@ -601,22 +609,23 @@ async function prerender404(prerenderedPageContexts, prerenderContext, onComplet
         }
     }
 }
-async function writeFiles({ urlOriginal, pageContext, htmlString, pageContextSerialized, doNotCreateExtraDirectory }, root, outDirClient, onPagePrerender, logLevel) {
+async function writeFiles({ urlOriginal, pageContext, htmlString, pageContextSerialized, doNotCreateExtraDirectory }, root, outDirClient, onPagePrerender, output, logLevel) {
     (0, utils_js_1.assert)(urlOriginal.startsWith('/'));
     const writeJobs = [
-        write(urlOriginal, pageContext, '.html', htmlString, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, logLevel)
+        write(urlOriginal, pageContext, 'HTML', htmlString, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, output, logLevel)
     ];
     if (pageContextSerialized !== null) {
-        writeJobs.push(write(urlOriginal, pageContext, '.pageContext.json', pageContextSerialized, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, logLevel));
+        writeJobs.push(write(urlOriginal, pageContext, 'JSON', pageContextSerialized, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, output, logLevel));
     }
     await Promise.all(writeJobs);
 }
-async function write(urlOriginal, pageContext, fileExtension, fileContent, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, logLevel) {
+async function write(urlOriginal, pageContext, fileType, fileContent, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, output, logLevel) {
     let fileUrl;
-    if (fileExtension === '.html') {
+    if (fileType === 'HTML') {
         fileUrl = (0, utils_js_1.urlToFile)(urlOriginal, '.html', doNotCreateExtraDirectory);
     }
     else {
+        (0, utils_js_1.assert)(fileType === 'JSON');
         fileUrl = (0, getPageContextRequestUrl_js_1.getPageContextRequestUrl)(urlOriginal);
     }
     (0, utils_js_1.assertPosixPath)(fileUrl);
@@ -628,6 +637,12 @@ async function write(urlOriginal, pageContext, fileExtension, fileContent, root,
     (0, utils_js_1.assertPosixPath)(outDirClient);
     (0, utils_js_1.assertPosixPath)(filePathRelative);
     const filePath = path_1.default.posix.join(outDirClient, filePathRelative);
+    output.push({
+        filePath,
+        fileType,
+        fileContent,
+        pageContext
+    });
     if (onPagePrerender) {
         const prerenderPageContext = {};
         (0, utils_js_1.objectAssign)(prerenderPageContext, pageContext);
@@ -796,3 +811,9 @@ prerenderConfig) {
         (0, utils_js_1.assertUsage)(false, `Setting ${picocolors_1.default.cyan(`prerender.${prop}`)} ${errMsg}`);
     }
 }
+function makePublic(prerenderContext) {
+    const prerenderContextPublic = (0, utils_js_1.makePublicCopy)(prerenderContext, 'prerenderContext', [
+        'pageContexts'
+    ]);
+    return prerenderContextPublic;
+}

package/dist/cjs/node/prerender/utils.js

@@ -22,9 +22,8 @@ __exportStar(require("../../utils/projectInfo.js"), exports);
 __exportStar(require("../../utils/objectAssign.js"), exports);
 __exportStar(require("../../utils/isObjectWithKeys.js"), exports);
 __exportStar(require("../../utils/isCallable.js"), exports);
-__exportStar(require("../../utils/getOutDirs.js"), exports);
 __exportStar(require("../../utils/isPropertyGetter.js"), exports);
-__exportStar(require("../../utils/filesystemPathHandling.js"), exports);
+__exportStar(require("../../utils/path.js"), exports);
 __exportStar(require("../../utils/urlToFile.js"), exports);
 __exportStar(require("../../utils/isPlainObject.js"), exports);
 __exportStar(require("../../utils/assertSetup.js"), exports);
@@ -33,3 +32,4 @@ __exportStar(require("../../utils/isFilePathAbsoluteFilesystem.js"), exports);
 __exportStar(require("../../utils/isArray.js"), exports);
 __exportStar(require("../../utils/isObject.js"), exports);
 __exportStar(require("../../utils/changeEnumerable.js"), exports);
+__exportStar(require("../../utils/makePublicCopy.js"), exports);