vike 0.4.219 → 0.4.220-commit-a9f46b8

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

@@ -4,7 +4,7 @@ export { runPrerenderFromAutoRun };
 export { runPrerender_forceExit };
 import path from 'path';
 import { route } from '../../shared/route/index.js';
-import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, pLimit, isArray, changeEnumerable, onSetupPrerender, isObject } from './utils.js';
+import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, pLimit, isArray, changeEnumerable, onSetupPrerender, isObject, makePublicCopy } from './utils.js';
 import { prerenderPage, prerender404Page, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
 import { cpus } from 'os';
@@ -27,6 +27,7 @@ import { logErrorHint } from '../runtime/renderPage/logErrorHint.js';
 import { executeHook, isUserHookError } from '../../shared/hooks/executeHook.js';
 import { getConfigValueBuildTime } from '../../shared/page-configs/getConfigValueBuildTime.js';
 import { prepareViteApiCall } from '../api/prepareViteApiCall.js';
+import { setContextIsPrerendering } from './context.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.
@@ -46,16 +47,20 @@ async function runPrerenderFromCLIPrerenderCommand() {
     runPrerender_forceExit();
 }
 async function runPrerenderFromAutoRun(viteConfig) {
+    let prerenderContextPublic;
     try {
-        await runPrerender({ viteConfig });
+        const ret = await runPrerender({ viteConfig });
+        prerenderContextPublic = ret.prerenderContextPublic;
     }
     catch (err) {
         console.error(err);
         logErrorHint(err);
         process.exit(1);
     }
+    return { prerenderContextPublic };
 }
 async function runPrerender(options = {}, standaloneTrigger) {
+    setContextIsPrerendering();
     checkOutdatedOptions(options);
     onSetupPrerender();
     setGlobalContext_isPrerendering();
@@ -82,35 +87,36 @@ async function runPrerender(options = {}, standaloneTrigger) {
     await initGlobalContext_runPrerender();
     const globalContext = getGlobalContext();
     globalContext.pageFilesAll.forEach(assertExportNames);
-    const prerenderContext = {};
-    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 = {};
     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);
+    warnContradictoryNoPrerenderList(prerenderContext.prerenderedPageContexts, doNotPrerenderList);
+    await prerender404(prerenderContext, onComplete);
     if (logLevel === 'info') {
         console.log(`${pc.green(`✓`)} ${prerenderedCount} HTML documents pre-rendered.`);
     }
-    warnMissingPages(prerenderedPageContexts, doNotPrerenderList, partial);
-    return { viteConfig };
+    warnMissingPages(prerenderContext.prerenderedPageContexts, doNotPrerenderList, partial);
+    const prerenderContextPublic = makePublic(prerenderContext);
+    return { viteConfig, prerenderContextPublic };
 }
 async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, concurrencyLimit) {
     // V1 design
@@ -301,7 +307,7 @@ function createPageContext(urlOriginal, prerenderContext) {
     const pageContext = {
         _urlHandler: null,
         _urlRewrite: null,
-        _noExtraDir: prerenderContext._noExtraDir,
+        _noExtraDir: prerenderContext.noExtraDir,
         _prerenderContext: prerenderContext
     };
     const pageContextInit = {
@@ -387,17 +393,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 executeHook(() => hookFn({
-        pageContexts: prerenderContext.pageContexts,
+    let result = await executeHook(() => {
+        const prerenderContextPublic = makePublic(prerenderContext);
         // TODO/v1-release: remove warning
-        get prerenderPageContexts() {
-            assertWarning(false, `prerenderPageContexts has been renamed pageContexts, see ${docLink}`, {
-                showStackTrace: true,
-                onlyOnce: true
-            });
-            return prerenderContext.pageContexts;
-        }
-    }), onPrerenderStartHook, null);
+        Object.defineProperty(prerenderContextPublic, 'prerenderPageContexts', {
+            get() {
+                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;
@@ -504,7 +513,7 @@ async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete)
             pageContext,
             htmlString: documentHtml,
             pageContextSerialized,
-            doNotCreateExtraDirectory: prerenderContext._noExtraDir,
+            doNotCreateExtraDirectory: prerenderContext.noExtraDir,
             pageId
         });
     })));
@@ -539,8 +548,8 @@ function warnMissingPages(prerenderedPageContexts, doNotPrerenderList, partial)
         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, onComplete) {
+    if (!Object.values(prerenderContext.prerenderedPageContexts).find(({ urlOriginal }) => urlOriginal === '/404')) {
         let result;
         try {
             result = await prerender404Page(prerenderContext.pageContextInit);
@@ -563,22 +572,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) {
     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 = urlToFile(urlOriginal, '.html', doNotCreateExtraDirectory);
     }
     else {
+        assert(fileType === 'JSON');
         fileUrl = getPageContextRequestUrl(urlOriginal);
     }
     assertPosixPath(fileUrl);
@@ -590,6 +600,12 @@ async function write(urlOriginal, pageContext, fileExtension, fileContent, root,
     assertPosixPath(outDirClient);
     assertPosixPath(filePathRelative);
     const filePath = path.posix.join(outDirClient, filePathRelative);
+    output.push({
+        filePath,
+        fileType,
+        fileContent,
+        pageContext
+    });
     if (onPagePrerender) {
         const prerenderPageContext = {};
         objectAssign(prerenderPageContext, pageContext);
@@ -758,3 +774,9 @@ prerenderConfig) {
         assertUsage(false, `Setting ${pc.cyan(`prerender.${prop}`)} ${errMsg}`);
     }
 }
+function makePublic(prerenderContext) {
+    const prerenderContextPublic = makePublicCopy(prerenderContext, 'prerenderContext', [
+        'pageContexts'
+    ]);
+    return prerenderContextPublic;
+}

package/dist/esm/node/prerender/utils.d.ts

@@ -15,3 +15,4 @@ export * from '../../utils/isFilePathAbsoluteFilesystem.js';
 export * from '../../utils/isArray.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/changeEnumerable.js';
+export * from '../../utils/makePublicCopy.js';

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

@@ -17,3 +17,4 @@ export * from '../../utils/isFilePathAbsoluteFilesystem.js';
 export * from '../../utils/isArray.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/changeEnumerable.js';
+export * from '../../utils/makePublicCopy.js';

package/dist/esm/node/runtime/globalContext.js

@@ -16,7 +16,7 @@ export { setGlobalContext_isViteDev };
 export { setGlobalContext_isPrerendering };
 export { setGlobalContext_buildEntry };
 export { clearGlobalContext };
-import { assert, onSetupRuntime, assertUsage, assertWarning, isPlainObject, objectAssign, objectReplace, objectKeys, isObject, hasProp, debugGlob, getGlobalObject, genPromise, createDebugger } from './utils.js';
+import { assert, onSetupRuntime, assertUsage, assertWarning, isPlainObject, objectAssign, objectReplace, isObject, hasProp, debugGlob, getGlobalObject, genPromise, createDebugger, makePublicCopy } from './utils.js';
 import { importServerProductionEntry } from '@brillout/vite-plugin-server-entry/runtime';
 import { virtualFileIdImportUserCodeServer } from '../shared/virtual-files/virtualFileImportUserCode.js';
 import { getPageFilesAll, setPageFiles, setPageFilesAsync } from '../../shared/getPageFiles/getPageFiles.js';
@@ -50,28 +50,8 @@ async function getGlobalContextAsync(isProduction) {
     return makePublic(globalContext);
 }
 function makePublic(globalContext) {
-    const globalContextPublic = {
-        // TODO/now: add viteConfig and vikeConfig
-        assetsManifest: globalContext.assetsManifest
-    };
-    // Add internals (and prepended _ prefix to their keys)
-    {
-        const publicKeys = Object.keys(globalContextPublic);
-        objectKeys(globalContext)
-            .filter((key) => !publicKeys.includes(key))
-            .forEach((key) => {
-            const keyPublic = `_${key}`;
-            Object.defineProperty(globalContextPublic, keyPublic, {
-                enumerable: true,
-                get() {
-                    assertWarning(false, `Using internal globalContext.${keyPublic} which is discouraged: it may break in any minor version update. Instead, reach out on GitHub and elaborate your use case.`, {
-                        onlyOnce: true
-                    });
-                    return globalContext[key];
-                }
-            });
-        });
-    }
+    // TODO/now: add viteConfig and vikeConfig
+    const globalContextPublic = makePublicCopy(globalContext, 'globalContext', ['assetsManifest']);
     return globalContextPublic;
 }
 function setGlobalContext_viteDevServer(viteDevServer) {

package/dist/esm/node/runtime/page-files/setup.js

@@ -1,3 +1,3 @@
 export {};
-// TODO/v1-release: remove
+// TODO/v1-release: remove https://github.com/vikejs/vike/issues/2122
 // This doesn't do anything anymore. (It's kept to avoid introducing a breaking change.)

package/dist/esm/node/runtime/utils.d.ts

@@ -56,3 +56,4 @@ export * from '../../utils/isVikeReactApp.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
+export * from '../../utils/makePublicCopy.js';

package/dist/esm/node/runtime/utils.js

@@ -60,3 +60,4 @@ export * from '../../utils/isVikeReactApp.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
+export * from '../../utils/makePublicCopy.js';

package/dist/esm/shared/page-configs/PageConfig.d.ts

@@ -32,9 +32,12 @@ type PageConfigBase = {
 type PageConfigRuntime = PageConfigBase & {
     configValues: ConfigValues;
     /** Load config values that are lazily loaded such as config.Page */
-    loadConfigValuesAll: () => Promise<{
-        configValuesSerialized: Record<string, ConfigValueSerialized>;
-    }>;
+    loadConfigValuesAll: () => {
+        moduleId: string;
+        moduleExports: Promise<{
+            configValuesSerialized: Record<string, ConfigValueSerialized>;
+        }>;
+    };
 };
 /** Same as PageConfigRuntime but also contains all lazily loaded config values such as config.Page */
 type PageConfigRuntimeLoaded = PageConfigRuntime & {

package/dist/esm/shared/page-configs/loadConfigValues.js

@@ -1,5 +1,5 @@
 export { loadConfigValues };
-import { objectAssign } from '../utils.js';
+import { assert, objectAssign } from '../utils.js';
 import { parseConfigValuesSerialized } from './serialize/parsePageConfigs.js';
 async function loadConfigValues(pageConfig, isDev) {
     if ('isAllLoaded' in pageConfig &&
@@ -7,7 +7,11 @@ async function loadConfigValues(pageConfig, isDev) {
         !isDev) {
         return pageConfig;
     }
-    const configValuesLoaded = await pageConfig.loadConfigValuesAll();
+    const { moduleId, moduleExports } = pageConfig.loadConfigValuesAll();
+    const configValuesLoaded = await moduleExports;
+    // `configValuesLoaded` is sometimes `undefined` https://github.com/vikejs/vike/discussions/2092
+    if (!configValuesLoaded)
+        assert(false, { moduleExports, configValuesLoaded, moduleId });
     const configValues = parseConfigValuesSerialized(configValuesLoaded.configValuesSerialized);
     Object.assign(pageConfig.configValues, configValues);
     objectAssign(pageConfig, { isAllLoaded: true });

package/dist/esm/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.219";
+export declare const PROJECT_VERSION: "0.4.220-commit-a9f46b8";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.219';
+export const PROJECT_VERSION = '0.4.220-commit-a9f46b8';

package/dist/esm/utils/assertSetup.js

@@ -116,7 +116,7 @@ function getEnvDescription() {
 // https://github.com/cloudflare/workers-sdk/issues/7886
 function assertNodeEnvIsNotUndefinedString() {
     const nodeEnv = getNodeEnv();
-    assertWarning(nodeEnv !== 'undefined', `${pc.cyan('process.env.NODE_ENV==="undefined"')} which is unexpected: ${pc.cyan('process.env.NODE_ENV')} can be set to the *value* ${pc.cyan('undefined')} (i.e. ${pc.cyan('process.env.NODE_ENV===undefined')}) but it shouldn't be set to the *string* ${pc.cyan('"undefined"')} ${pc.underline('https://vike.dev/NODE_ENV')}`, { onlyOnce: true });
+    assertWarning(nodeEnv !== 'undefined', `${pc.cyan('process.env.NODE_ENV==="undefined"')} which is unexpected: ${pc.cyan('process.env.NODE_ENV')} is allowed to be the *value* ${pc.cyan('undefined')} (i.e. ${pc.cyan('process.env.NODE_ENV===undefined')}) but it shouldn't be the *string* ${pc.cyan('"undefined"')} ${pc.underline('https://vike.dev/NODE_ENV')}`, { onlyOnce: true });
 }
 function isNodeEnvDev() {
     const nodeEnv = getNodeEnv();
@@ -136,6 +136,20 @@ function getNodeEnv() {
     catch {
         return undefined;
     }
+    /*
+    // Should we show the following warning? So far I don't think so because of the following. Maybe we can show it once we enable users to disable warnings.
+    // - The warning isn't always actionable, e.g. if it's a tool that dynamically sets `process.env.NODE_ENV`.
+    // - We assume that tools use `process.env.NODE_ENV` and not someting like `const { env } = process; env.NODE_ENV`. Thus, in practice, `val` overrides `val2` so having `val!==val2` isn't an issue.
+    {
+      const val2 = process.env['NODE' + '_ENV']
+      if (val2)
+        assertWarning(
+          val === val2,
+          `Dynamically setting process.env.NODE_ENV to ${val2} hasn't any effect because process.env.NODE_ENV is being statically replaced to ${val}.`,
+          { onlyOnce: true }
+        )
+    }
+    //*/
     return val;
 }
 function setNodeEnvProduction() {

package/dist/esm/utils/catchInfiniteLoop.d.ts

@@ -0,0 +1,2 @@
+export { catchInfiniteLoop };
+declare function catchInfiniteLoop(functionName: `${string}()`, maxNumberOfCalls?: number, withinSeconds?: number): void;

package/dist/esm/utils/catchInfiniteLoop.js

@@ -0,0 +1,32 @@
+export { catchInfiniteLoop };
+import { assert, assertWarning } from './assert.js';
+const trackers = {};
+function catchInfiniteLoop(functionName, maxNumberOfCalls = 100, withinSeconds = 5) {
+    // Init
+    const now = new Date();
+    let tracker = (trackers[functionName] ?? (trackers[functionName] = createTracker(now)));
+    // Reset
+    const elapsedTime = now.getTime() - tracker.start.getTime();
+    if (elapsedTime > withinSeconds * 1000)
+        tracker = trackers[functionName] = createTracker(now);
+    // Count
+    tracker.count++;
+    // Error
+    const msg = `[Infinite Loop] ${functionName} called ${tracker.count} times within ${withinSeconds} seconds`;
+    if (tracker.count > maxNumberOfCalls) {
+        assert(false, msg);
+    }
+    // Warning, at 50% threshold
+    if (!tracker.warned && tracker.count > maxNumberOfCalls * 0.5) {
+        // Warning is shown upon 10 calls a second, on average during 5 seconds, given the default parameters
+        assertWarning(false, msg, { onlyOnce: false });
+        tracker.warned = true;
+    }
+}
+function createTracker(now) {
+    const tracker = {
+        count: 0,
+        start: now
+    };
+    return tracker;
+}

package/dist/esm/utils/isDev.js

@@ -5,6 +5,8 @@ import { assert } from './assert.js';
 function isDevCheck(configEnv) {
     const { isPreview, command } = configEnv;
     // Released at vite@5.1.0 which is guaranteed with `assertVersion('Vite', version, '5.1.0')`
+    // - Release: https://github.com/vitejs/vite/blob/6f7466e6211027686f40ad7e4ce6ec8477414546/packages/vite/CHANGELOG.md#510-beta4-2024-01-26:~:text=fix(preview)%3A-,set%20isPreview%20true,-(%2315695)%20(93fce55
+    // - Surprisingly, this assert() can fail: https://github.com/vikejs/vike/issues/2120
     assert(typeof isPreview === 'boolean');
     return command === 'serve' && !isPreview;
 }

package/dist/esm/utils/makePublicCopy.d.ts

@@ -0,0 +1,3 @@
+export { makePublicCopy };
+/** Prefix internal properties with `_` + show warning */
+declare function makePublicCopy<Obj extends Record<string, unknown>, PropsPublic extends readonly (keyof Obj)[]>(obj: Obj, objName: string, propsPublic: PropsPublic, propsInternalNoWarning?: (keyof Obj)[]): Pick<Obj, PropsPublic[number]>;

package/dist/esm/utils/makePublicCopy.js

@@ -0,0 +1,30 @@
+export { makePublicCopy };
+import { assertWarning } from './assert.js';
+import { objectKeys } from './objectKeys.js';
+/** Prefix internal properties with `_` + show warning */
+function makePublicCopy(obj, objName, propsPublic, propsInternalNoWarning) {
+    const objPublic = {};
+    objectKeys(obj).forEach((key) => {
+        const val = obj[key];
+        if (propsPublic.includes(key)) {
+            objPublic[key] = val;
+        }
+        else {
+            const keyPublic = key.startsWith('_') ? key : `_${key}`;
+            if (propsInternalNoWarning?.includes(key)) {
+                // @ts-expect-error
+                objPublic[keyPublic] = val;
+            }
+            else {
+                Object.defineProperty(objPublic, keyPublic, {
+                    enumerable: true,
+                    get() {
+                        assertWarning(false, `Using internal ${objName}.${keyPublic} which may break in any minor version update. Reach out on GitHub and elaborate your use case so that the Vike team can add official support for your use case.`, { onlyOnce: true });
+                        return val;
+                    }
+                });
+            }
+        }
+    });
+    return objPublic;
+}

package/dist/esm/utils/projectInfo.d.ts

@@ -1,4 +1,4 @@
 export declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.219";
+    projectVersion: "0.4.220-commit-a9f46b8";
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.219",
+  "version": "0.4.220-commit-a9f46b8",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {