vike 0.4.159 → 0.4.160-commit-30d535e

package/dist/esm/node/plugin/plugins/previewConfig.js

@@ -1,5 +1,5 @@
 export { previewConfig };
-import { assertUsage, getOutDirs, resolveOutDir, markEnvAsPreview } from '../utils.js';
+import { assertUsage, getOutDirs, resolveOutDir, markEnvAsVitePreview } from '../utils.js';
 import { getConfigVike } from '../../shared/getConfigVike.js';
 import fs from 'fs';
 import path from 'path';
@@ -28,7 +28,7 @@ function previewConfig() {
                - This ugly hack to set appType for preview won't be need once https://github.com/vitejs/vite/pull/14855 is merged.
             config.appType = 'mpa'
             */
-            markEnvAsPreview();
+            markEnvAsVitePreview();
             return () => {
                 assertDist();
                 /* We don't use this condition (we wrongfully always use the SSR middleware) because of the regression introduced by https://github.com/vitejs/vite/pull/14756 which stops servering .html files when `appType: 'custom'`.

package/dist/esm/node/plugin/shared/getHttpRequestAsyncStore.js

@@ -12,7 +12,7 @@ export { getHttpRequestAsyncStore };
 export { installHttpRequestAsyncStore };
 import { renderPage_addWrapper } from '../../runtime/renderPage.js';
 import { assert, assertIsNotProductionRuntime, isObject } from '../utils.js';
-import { getConfigBuildErrorFormatted } from '../plugins/importUserCode/v1-design/transpileAndExecuteFile.js';
+import { getConfigBuildErrorFormatted } from '../plugins/importUserCode/v1-design/getVikeConfig/transpileAndExecuteFile.js';
 import { logErrorDebugNote } from './loggerNotProd.js';
 import { isEquivalentErrorWithCodeSnippet } from './loggerNotProd/errorWithCodeSnippet.js';
 assertIsNotProductionRuntime();

package/dist/esm/node/plugin/shared/loggerNotProd/log.js

@@ -20,10 +20,10 @@ function logWithVikeTag(msg, logType, category, showVikeVersion = false) {
 function getProjectTag(showVikeVersion) {
     let projectTag;
     if (showVikeVersion) {
-        projectTag = `[${projectInfo.npmPackageName}@${projectInfo.projectVersion}]`;
+        projectTag = `[vike@${projectInfo.projectVersion}]`;
     }
     else {
-        projectTag = `[${projectInfo.npmPackageName}]`;
+        projectTag = `[vike]`;
     }
     return projectTag;
 }
@@ -83,7 +83,7 @@ function prependTags(msg, projectTag, category, logType) {
             return pc.yellow(s);
         if (projectTag === '[vite]')
             return pc.bold(pc.cyan(s));
-        if (projectTag.startsWith(`[${projectInfo.npmPackageName}`))
+        if (projectTag.startsWith(`[vike`))
             return pc.bold(pc.cyan(s));
         assert(false);
     };

package/dist/esm/node/plugin/shared/loggerNotProd.js

@@ -18,7 +18,7 @@ import { assert, assertIsNotProductionRuntime, formatHintLog, getAssertErrMsg, i
 import { getHttpRequestAsyncStore } from './getHttpRequestAsyncStore.js';
 import { isErrorDebug } from './isErrorDebug.js';
 import { isErrorWithCodeSnippet, getPrettyErrorWithCodeSnippet } from './loggerNotProd/errorWithCodeSnippet.js';
-import { getConfigExecutionErrorIntroMsg, getConfigBuildErrorFormatted } from '../plugins/importUserCode/v1-design/transpileAndExecuteFile.js';
+import { getConfigExecutionErrorIntroMsg, getConfigBuildErrorFormatted } from '../plugins/importUserCode/v1-design/getVikeConfig/transpileAndExecuteFile.js';
 import { logWithVikeTag, logWithViteTag, logDirectly, isFirstLog, screenHasErrors, clearScreen, applyViteSourceMapToStackTrace } from './loggerNotProd/log.js';
 import pc from '@brillout/picocolors';
 import { setAlreadyLogged } from '../../runtime/renderPage/isNewError.js';

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

@@ -5,7 +5,6 @@ export * from '../../utils/getDependencyPackageJson.js';
 export * from '../../utils/requireResolve.js';
 export * from '../../utils/arrayIncludes.js';
 export * from '../../utils/isDev.js';
-export * from '../../utils/objectKeys.js';
 export * from '../../utils/getMostSimilar.js';
 export * from '../../utils/getRandomId.js';
 export * from '../../utils/joinEnglish.js';
@@ -13,7 +12,7 @@ export * from '../../utils/escapeRegex.js';
 export * from '../../utils/stripAnsi.js';
 export * from '../../utils/trimWithAnsi.js';
 export * from '../../utils/removeEmptyLines.js';
-export * from '../../utils/findUserPackageJsonPath.js';
+export * from '../../utils/findFile.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/mergeCumulativeValues.js';
 export * from '../../utils/deepEqual.js';

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

@@ -11,7 +11,6 @@ export * from '../../utils/getDependencyPackageJson.js';
 export * from '../../utils/requireResolve.js';
 export * from '../../utils/arrayIncludes.js';
 export * from '../../utils/isDev.js';
-export * from '../../utils/objectKeys.js';
 export * from '../../utils/getMostSimilar.js';
 export * from '../../utils/getRandomId.js';
 export * from '../../utils/joinEnglish.js';
@@ -19,7 +18,7 @@ export * from '../../utils/escapeRegex.js';
 export * from '../../utils/stripAnsi.js';
 export * from '../../utils/trimWithAnsi.js';
 export * from '../../utils/removeEmptyLines.js';
-export * from '../../utils/findUserPackageJsonPath.js';
+export * from '../../utils/findFile.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/mergeCumulativeValues.js';
 export * from '../../utils/deepEqual.js';

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

@@ -5,7 +5,7 @@ export { runPrerender_forceExit };
 import '../runtime/page-files/setup.js';
 import path from 'path';
 import { route } from '../../shared/route/index.js';
-import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, executeHook, isPlainObject, setNodeEnvToProduction, isUserHookError } from './utils.js';
+import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, executeHook, isPlainObject, setNodeEnvToProduction, isUserHookError, assertNodeEnvIsNotDev, getNodeEnv } from './utils.js';
 import { pLimit } from '../../utils/pLimit.js';
 import { prerenderPage, prerender404Page, getRenderContext, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
@@ -26,11 +26,11 @@ import { loadUserFilesServerSide } from '../runtime/renderPage/loadUserFilesServ
 import { getHookFromPageConfig, getHookFromPageConfigGlobal, getHookTimeoutDefault, setIsPrerenderering } from '../../shared/hooks/getHook.js';
 import { noRouteMatch } from '../../shared/route/noRouteMatch.js';
 import { getVikeConfig } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
-import { logHintForCjsEsmError } from '../runtime/renderPage/logHintForCjsEsmError.js';
+import { logErrorHint } from '../runtime/renderPage/logErrorHint.js';
 async function runPrerenderFromAPI(options = {}) {
     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.
-    // - We don't use logHintForCjsEsmError() because we don't have control over what happens with the error. For example, if the user land purposely swallows the error then the hint shouldn't be logged. Also, it's best if the hint is shown to the user *after* the error, but we cannot do/guarentee that.
+    // - We don't use logErrorHint() because we don't have control over what happens with the error. For example, if the user land purposely swallows the error then the hint shouldn't be logged. Also, it's best if the hint is shown to the user *after* the error, but we cannot do/guarentee that.
 }
 async function runPrerenderFromCLI(options) {
     try {
@@ -38,7 +38,7 @@ async function runPrerenderFromCLI(options) {
     }
     catch (err) {
         console.error(err);
-        logHintForCjsEsmError(err);
+        logErrorHint(err);
         process.exit(1);
     }
 }
@@ -48,7 +48,7 @@ async function runPrerenderFromAutoFullBuild(options) {
     }
     catch (err) {
         console.error(err);
-        logHintForCjsEsmError(err);
+        logErrorHint(err);
         process.exit(1);
     }
 }
@@ -59,7 +59,7 @@ async function runPrerender(options, manuallyTriggered) {
     if (logLevel === 'info') {
         console.log(`${pc.cyan(`vike v${projectInfo.projectVersion}`)} ${pc.green('pre-rendering HTML...')}`);
     }
-    setNodeEnvToProduction();
+    handleNodeEnv();
     await disableReactStreaming();
     const viteConfig = await resolveConfig(options.viteConfig || {}, 'vike pre-rendering', 'production');
     assertLoadedConfig(viteConfig, options);
@@ -713,3 +713,10 @@ function assertIsNotAbort(err, urlOr404) {
     assert(abortCall);
     assertUsage(false, `${pc.cyan(abortCall)} thrown${thrownBy} while pre-rendering ${urlOr404} but ${pc.cyan(abortCaller)} isn't supported for pre-rendered pages`);
 }
+function handleNodeEnv() {
+    const assertNodeEnv = () => assertNodeEnvIsNotDev('pre-rendering');
+    if (getNodeEnv())
+        assertNodeEnv();
+    setNodeEnvToProduction();
+    assertNodeEnv();
+}

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

@@ -6,7 +6,7 @@ export { setGlobalContext_viteDevServer };
 export { setGlobalContext_vitePreviewServer };
 export { setGlobalContext_viteConfig };
 export { getRuntimeManifest };
-import { assert, assertUsage, assertWarning, getGlobalObject, getNodeEnv, isPlainObject, objectAssign } from './utils.js';
+import { assert, assertUsage, getGlobalObject, getNodeEnv, getNodeEnvDesc, isNodeEnvDev, isPlainObject, objectAssign } from './utils.js';
 import { loadImportBuild } from './globalContext/loadImportBuild.js';
 import { setPageFiles } from '../../shared/getPageFiles.js';
 import { assertPluginManifest } from '../shared/assertPluginManifest.js';
@@ -151,7 +151,11 @@ function assertNodeEnv(hasViteDevServer) {
     const nodeEnv = getNodeEnv();
     if (nodeEnv === null || nodeEnv === 'test')
         return;
-    const isDevNodeEnv = [undefined, '', 'dev', 'development'].includes(nodeEnv);
-    // calling Vite's createServer() is enough for hasViteDevServer to be true, even without actually adding Vite's development middleware to the server: https://github.com/vikejs/vike/issues/792#issuecomment-1516830759
-    assertWarning(hasViteDevServer === isDevNodeEnv, `Vite's development server was${hasViteDevServer ? '' : "n't"} instantiated while the environment is set to be a ${isDevNodeEnv ? 'development' : 'production'} environment by ${pc.cyan(`process.env.NODE_ENV === ${JSON.stringify(nodeEnv)}`)} which is contradictory, see https://vike.dev/NODE_ENV`, { onlyOnce: true });
+    const isDev = isNodeEnvDev();
+    // Calling Vite's createServer() is enough for hasViteDevServer to be true, even without actually adding Vite's development middleware to the server: https://github.com/vikejs/vike/issues/792#issuecomment-1516830759
+    if (hasViteDevServer === isDev)
+        return;
+    const nodeEnvDesc = getNodeEnvDesc();
+    // We should change this to be a warning if it blocks users (e.g. if a bad-citizen tool sets a wrong process.env.NODE_ENV value)
+    assertUsage(false, `Vite's development server was${hasViteDevServer ? '' : "n't"} instantiated while the ${nodeEnvDesc} which is contradictory, see https://vike.dev/NODE_ENV`);
 }

package/dist/esm/node/runtime/html/injectAssets/getHtmlTags.js

@@ -85,8 +85,8 @@ async function getHtmlTags(pageContext, injectToStream, injectFilter) {
     // See https://github.com/vikejs/vike/pull/1271
     const positionJavaScriptEntry = (() => {
         if (pageContext._pageContextPromise) {
-            assertWarning(!injectToStream, "[getHtmlTags()] We recommend against using streaming and a pageContext promise at the same time as progressive hydration won't work", { onlyOnce: true });
-            // If there is a pageContext._pageContextPromise (which is resolved after the stream has ended) then the pageContext JSON data needs to await for it: https://vike.dev/stream#initial-data-after-stream-end
+            assertWarning(!injectToStream, "[getHtmlTags()] We recommend against using streaming and a pageContext promise at the same time, because progressive hydration won't work.", { onlyOnce: true });
+            // If there is a pageContext._pageContextPromise (which is resolved after the stream has ended) then the pageContext JSON data needs to await for it: https://vike.dev/streaming#initial-data-after-stream-end
             return 'HTML_END';
         }
         if (injectToStream) {

package/dist/esm/node/runtime/html/renderHtml.js

@@ -181,7 +181,7 @@ async function renderTemplate(templateContent, pageContext) {
             const varType = typeof templateVar;
             const streamNote = ['boolean', 'number', 'bigint', 'symbol'].includes(varType)
                 ? null
-                : '(See https://vike.dev/stream for HTML streaming.)';
+                : '(See https://vike.dev/streaming for HTML streaming.)';
             assertUsage(varType === 'string', getErrMsg(pc.cyan(`typeof htmlVar === "${varType}"`), streamNote));
         }
         {

package/dist/esm/node/runtime/html/stream.js

@@ -634,7 +634,7 @@ function isStream(something) {
 const __streamPipeWeb = '__streamPipeWeb';
 /** @deprecated */
 function pipeWebStream(pipe) {
-    assertWarning(false, 'pipeWebStream() is outdated, use stampPipe() instead. See https://vike.dev/stream', {
+    assertWarning(false, 'pipeWebStream() is outdated, use stampPipe() instead. See https://vike.dev/streaming', {
         onlyOnce: true,
         showStackTrace: true
     });
@@ -669,7 +669,7 @@ function isStreamPipeWeb(thing) {
 const __streamPipeNode = '__streamPipeNode';
 /** @deprecated */
 function pipeNodeStream(pipe) {
-    assertWarning(false, 'pipeNodeStream() is outdated, use stampPipe() instead. See https://vike.dev/stream', {
+    assertWarning(false, 'pipeNodeStream() is outdated, use stampPipe() instead. See https://vike.dev/streaming', {
         onlyOnce: true,
         showStackTrace: true
     });

package/dist/esm/node/runtime/renderPage/executeOnRenderHtmlHook.js

@@ -119,11 +119,11 @@ function processHookReturnValue(hookReturnValue, renderHook) {
         const val = hookReturnValue.pageContext;
         const errBegin = `${errPrefix} returned ${pc.cyan('{ pageContext }')}, but ${pc.cyan('pageContext')}`;
         if (isPromise(val) || isCallable(val)) {
-            assertWarning(!isPromise(val), `${errBegin} is a promise which is deprecated in favor of async functions, see https://vike.dev/stream#initial-data-after-stream-end`, { onlyOnce: true });
+            assertWarning(!isPromise(val), `${errBegin} is a promise which is deprecated in favor of async functions, see https://vike.dev/streaming#initial-data-after-stream-end`, { onlyOnce: true });
             pageContextPromise = val;
         }
         else {
-            assertUsage(isObject(val), `${errBegin} should be an object or an async function, see https://vike.dev/stream#initial-data-after-stream-end`);
+            assertUsage(isObject(val), `${errBegin} should be an object or an async function, see https://vike.dev/streaming#initial-data-after-stream-end`);
             assertPageContextProvidedByUser(val, renderHook);
             pageContextProvidedByRenderHook = val;
         }

package/dist/esm/node/runtime/renderPage/getHttpResponseBody.js

@@ -4,7 +4,7 @@ import { isStream, getStreamName, inferStreamName, isStreamWritableWeb, isStream
 import { assert, assertUsage, assertWarning } from '../utils.js';
 import { getHtmlString } from '../html/renderHtml.js';
 import pc from '@brillout/picocolors';
-const streamDocs = 'See https://vike.dev/stream for more information.';
+const streamDocs = 'See https://vike.dev/streaming for more information.';
 function getHttpResponseBody(htmlRender, renderHook) {
     if (typeof htmlRender !== 'string') {
         assertUsage(false, getErrMsg(htmlRender, renderHook, 'body', `Use ${pc.cyan('pageContext.httpResponse.pipe()')} instead`));

package/dist/esm/node/runtime/renderPage/loadUserFilesServerSide.js

@@ -42,7 +42,7 @@ async function loadUserFilesServerSide(pageContext) {
     // TODO/v1-release: remove
     Object.assign(pageContextAddendum, {
         _getPageAssets: async () => {
-            assertWarning(false, 'pageContext._getPageAssets() deprecated, see https://vike.dev/preload', {
+            assertWarning(false, 'pageContext._getPageAssets() deprecated, see https://vike.dev/preloading', {
                 onlyOnce: true,
                 showStackTrace: true
             });

package/dist/esm/node/runtime/renderPage/logErrorHint.d.ts

@@ -0,0 +1,8 @@
+export { logErrorHint };
+export { isCjsEsmError };
+export { isKnownError };
+export { getHint };
+declare function logErrorHint(error: unknown): void;
+declare function getHint(error: unknown): null | string;
+declare function isKnownError(error: unknown): false | string;
+declare function isCjsEsmError(error: unknown): boolean | string[];

package/dist/esm/node/runtime/renderPage/{logHintForCjsEsmError.js → logErrorHint.js}

@@ -1,12 +1,22 @@
-export { logHintForCjsEsmError };
-// For ./logHintForCjsEsmError/*.spec.ts
+export { logErrorHint };
+// For ./logErrorHint/*.spec.ts
 export { isCjsEsmError };
-export { isReactInvalidComponentError };
+export { isKnownError };
 export { getHint };
 import pc from '@brillout/picocolors';
 import { assert, formatHintLog, isNotNullish, isObject, unique, joinEnglish } from '../utils.js';
-function logHintForCjsEsmError(error) {
-    /* Collect errors for ./logHintForCjsEsmError.spec.ts
+const knownErrors = [
+    {
+        errMsg: 'jsxDEV is not a function',
+        link: 'https://github.com/vikejs/vike/issues/1469#issuecomment-1919518096'
+    },
+    {
+        errMsg: 'Element type is invalid: expected a string (for built-in components) or a class/function (for composite components)',
+        link: 'https://vike.dev/broken-npm-package#react-invalid-component'
+    }
+];
+function logErrorHint(error) {
+    /* Collect errors for ./logErrorHint.spec.ts
     collectError(error)
     //*/
     const hint = getHint(error);
@@ -14,9 +24,10 @@ function logHintForCjsEsmError(error) {
         logHint(hint);
 }
 function getHint(error) {
-    if (isReactInvalidComponentError(error)) {
-        const hint = 'To fix this error, see https://vike.dev/broken-npm-package#react-invalid-component';
-        return hint;
+    {
+        const link = isKnownError(error);
+        if (link)
+            return `To fix this error, see ${link}`;
     }
     const res = isCjsEsmError(error);
     if (res) {
@@ -37,43 +48,71 @@ function logHint(hint) {
     hint = formatHintLog(hint);
     console.error(hint);
 }
-function isReactInvalidComponentError(error) {
+function isKnownError(error) {
     const anywhere = getAnywhere(error);
-    return includes(anywhere, 'Element type is invalid: expected a string (for built-in components) or a class/function (for composite components)');
+    const knownErr = knownErrors.find((knownErorr) => {
+        return includes(anywhere, knownErorr.errMsg);
+    });
+    if (!knownErr)
+        return false;
+    return knownErr.link;
 }
-/**
- * `false` -> noop
- * `true` -> generic message
- * `'some-npm-package'` -> add some-npm-package to `ssr.noExternal`
- */
+// `false` -> noop
+// `true` -> generic message
+// `'some-npm-package'` -> add some-npm-package to `ssr.noExternal`
 function isCjsEsmError(error) {
+    const res = check(error);
+    if (res === true || res === false)
+        return res;
+    const packageNames = normalizeRes(res);
+    if (packageNames === false)
+        return packageNames;
+    packageNames.forEach((packageName) => {
+        assert(!['vite', 'vike'].includes(packageName));
+    });
+    return packageNames;
+}
+function normalizeRes(res) {
+    let packageNames = Array.isArray(res) ? res : [res];
+    packageNames = unique(packageNames.filter(isNotNullish).filter((packageName) => packageName !== '@brillout/import'));
+    if (packageNames.length === 0)
+        return false;
+    return packageNames;
+}
+function check(error) {
     const message = getErrMessage(error);
     const anywhere = getAnywhere(error);
     const packageName_stack1 = getPackageName_stack1(error);
     const packageName_stack2 = getPackageName_stack2(error);
     const isRelatedToNodeModules = !!packageName_stack1 || !!packageName_stack2 || includesNodeModules(message);
-    // const relatedNpmPackages = normalize([packageName_stack1, packageName_stack2, extractFromNodeModulesPath(message)])
+    /*
+    const relatedNpmPackages = normalizeArray([
+      packageName_stack1 || null,
+      packageName_stack2 || null,
+      (message && extractFromNodeModulesPath(message)) || null
+    ])
+    */
     // ERR_UNSUPPORTED_DIR_IMPORT
     {
-        const packageNames = parseNodeModulesPathMessage('ERR_UNSUPPORTED_DIR_IMPORT', anywhere);
-        if (packageNames)
-            return packageNames;
+        const packageName = parseNodeModulesPathMessage('ERR_UNSUPPORTED_DIR_IMPORT', anywhere);
+        if (packageName)
+            return packageName;
     }
     // ERR_UNKNOWN_FILE_EXTENSION
     {
-        const packageNames = parseUnkownFileExtensionMessage(anywhere);
-        if (packageNames)
-            return packageNames;
+        const packageName = parseUnkownFileExtensionMessage(anywhere);
+        if (packageName)
+            return packageName;
     }
     {
-        const packageNames = parseNodeModulesPathMessage('ERR_UNKNOWN_FILE_EXTENSION', anywhere);
-        if (packageNames)
-            return packageNames;
+        const packageName = parseNodeModulesPathMessage('ERR_UNKNOWN_FILE_EXTENSION', anywhere);
+        if (packageName)
+            return packageName;
     }
     {
-        const packageNames = parseNodeModulesPathMessage('is not exported', anywhere);
-        if (packageNames)
-            return packageNames;
+        const packageName = parseNodeModulesPathMessage('is not exported', anywhere);
+        if (packageName)
+            return packageName;
     }
     // Using CJS inside ESM modules.
     if (includes(anywhere, 'require is not a function') ||
@@ -94,7 +133,7 @@ function isCjsEsmError(error) {
     if (includes(anywhere, 'ERR_REQUIRE_ESM')) {
         /* The issue is the importer, not the importee.
         if (relatedNpmPackages) return relatedNpmPackages
-        */
+         */
         {
             if (packageName_stack1)
                 return packageName_stack1;
@@ -114,9 +153,9 @@ function isCjsEsmError(error) {
     */
     // `SyntaxError: Named export '${exportName}' not found. The requested module '${packageName}' is a CommonJS module, which may not support all module.exports as named exports.`
     {
-        const packageNames = parseImportFrom(anywhere);
-        if (packageNames)
-            return packageNames;
+        const packageName = parseImportFrom(anywhere);
+        if (packageName)
+            return packageName;
     }
     if (includes(anywhere, 'Cannot read properties of undefined')) {
         if (isRelatedToNodeModules) {
@@ -152,7 +191,7 @@ function parseCannotFindMessage(str) {
         return false;
     // const packageNameCannotFind = extractFromPath(match[1]!)
     const packageNameFrom = extractFromPath(match[2]);
-    return normalize([
+    return normalizeArray([
         // packageNameCannotFind,
         packageNameFrom
     ]);
@@ -163,7 +202,7 @@ function parseUnkownFileExtensionMessage(str) {
         return false;
     const filePath = match[1];
     const packageName = extractFromPath(filePath);
-    return normalize([packageName]);
+    return packageName;
 }
 function parseImportFrom(str) {
     const match = /\bimport\b.*?\bfrom\b\s*?"(.+?)"/.exec(str);
@@ -171,7 +210,7 @@ function parseImportFrom(str) {
         return false;
     const importPath = match[1];
     const packageName = extractFromPath(importPath);
-    return normalize([packageName]);
+    return packageName;
 }
 function parseNodeModulesPathMessage(begin, str) {
     str = str.replaceAll('\\', '/');
@@ -225,7 +264,6 @@ function extractFromPath(filePath) {
         packageName = packageName.split('/')[0];
     }
     packageName = clean(packageName);
-    assert(!['vite', 'vike'].includes(packageName));
     return packageName;
 }
 function clean(packageName) {
@@ -243,7 +281,7 @@ function extractFromNodeModulesPath(str) {
         return false;
     const packageName = extractFromPath(str);
     assert(packageName);
-    return normalize([packageName]);
+    return packageName;
 }
 function includes(str1, str2) {
     return !!str1 && str1.toLowerCase().includes(str2.toLowerCase());
@@ -258,11 +296,11 @@ function includesNodeModules(str) {
         return false;
     return true;
 }
-function normalize(packageNames) {
-    const result = unique(packageNames.filter(isNotNullish).filter((packageName) => packageName !== '@brillout/import'));
-    if (result.length === 0)
-        return false;
-    return result;
+function normalizeArray(arr) {
+    const arrNormalized = arr.filter(isNotNullish);
+    if (arrNormalized.length === 0)
+        return null;
+    return arrNormalized;
 }
 function getErrMessage(err) {
     if (!isObject(err))

package/dist/esm/node/runtime/renderPage/loggerProd.js

@@ -6,7 +6,7 @@ import { isAbortError } from '../../../shared/route/abort.js';
 import { setAlreadyLogged } from './isNewError.js';
 import { isObject, warnIfErrorIsNotObject } from '../utils.js';
 import pc from '@brillout/picocolors';
-import { logHintForCjsEsmError } from './logHintForCjsEsmError.js';
+import { logErrorHint } from './logErrorHint.js';
 function logErrorProd(err, _httpRquestId) {
     warnIfErrorIsNotObject(err);
     setAlreadyLogged(err);
@@ -20,6 +20,6 @@ function logErrorProd(err, _httpRquestId) {
 }
 // Every server-side runtime error is expected to go through onRuntimeError(). (In principle, any runtime error is (or at least should) be catched by Vike, otherwise Vike couldn't render the error page.)
 function onRuntimeError(err) {
-    // The more runtime errors we pass to logHintForCjsEsmError() the better.
-    logHintForCjsEsmError(err);
+    // The more runtime errors we pass to logErrorHint() the better.
+    logErrorHint(err);
 }

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

@@ -36,7 +36,7 @@ export * from '../../utils/isNpmPackage.js';
 export * from '../../utils/isNotNullish.js';
 export * from '../../utils/isScriptFile.js';
 export * from '../../utils/removeFileExtention.js';
-export * from '../../utils/objectEntries.js';
+export * from '../../utils/objectKeys.js';
 export * from '../../utils/isStringRecord.js';
 export * from '../../utils/getFileExtension.js';
 export * from '../../utils/assertIsNotProductionRuntime.js';

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

@@ -39,7 +39,7 @@ export * from '../../utils/isNpmPackage.js';
 export * from '../../utils/isNotNullish.js';
 export * from '../../utils/isScriptFile.js';
 export * from '../../utils/removeFileExtention.js';
-export * from '../../utils/objectEntries.js';
+export * from '../../utils/objectKeys.js';
 export * from '../../utils/isStringRecord.js';
 export * from '../../utils/getFileExtension.js';
 export * from '../../utils/assertIsNotProductionRuntime.js';

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

@@ -201,7 +201,7 @@ type OnRenderHtmlSync = (pageContext: PageContextServer) => DocumentHtml | {
     pageContext: OnRenderHtmlPageContextReturn | (() => Promise<OnRenderHtmlPageContextReturn> | OnRenderHtmlPageContextReturn);
 };
 type OnRenderHtmlPageContextReturn = Partial<Vike.PageContext & {
-    /** See https://vike.dev/stream */
+    /** See https://vike.dev/streaming */
     enableEagerStreaming: boolean;
 }>;
 /** @deprecated Use a sync route() with an async guard() instead */

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

@@ -17,6 +17,7 @@ export type { DefinedAtFileFullInfo };
 export type { FilePathResolved };
 export type { FilePath };
 import type { ConfigValueImported, ConfigValueSerialized } from './serialize/PageConfigSerialized.js';
+import type { LocationId } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/filesystemRouting.js';
 type PageConfigBase = {
     pageId: string;
     isErrorPage?: true;
@@ -53,6 +54,10 @@ type PageConfigGlobalRuntime = {
 type PageConfigGlobalBuildTime = {
     configValueSources: ConfigValueSources;
 };
+/** In what environment(s) the config value is loaded.
+ *
+ * https://vike.dev/meta
+ */
 type ConfigEnv = {
     client?: boolean;
     server?: boolean;
@@ -67,6 +72,7 @@ type ConfigValueSource = {
     value?: unknown;
     configEnv: ConfigEnvInternal;
     definedAt: DefinedAtFileFullInfo;
+    locationId: LocationId;
     /** Wether the config value is loaded at runtime, for example config.Page or config.onBeforeRender */
     valueIsImportedAtRuntime: boolean;
     /** Whether the config value is a file path, for example config.client */

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

@@ -0,0 +1,2 @@
+export { assertPlusFileExport };
+declare function assertPlusFileExport(fileExports: Record<string, unknown>, filePathToShowToUser: string, configName: string): void;

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

@@ -0,0 +1,38 @@
+export { assertPlusFileExport };
+import { assert, assertUsage, assertWarning } from '../utils.js';
+import pc from '@brillout/picocolors';
+const EXPORTS_IGNORE = [
+    // vite-plugin-solid adds `export { $$registrations }`
+    '$$registrations',
+    // @vitejs/plugin-vue adds `export { _rerender_only }`
+    '_rerender_only'
+];
+// Tolerate `export { frontmatter }` in .mdx files
+const TOLERATE_SIDE_EXPORTS = ['.md', '.mdx'];
+function assertPlusFileExport(fileExports, filePathToShowToUser, configName) {
+    const exportsAll = Object.keys(fileExports).filter((exportName) => !EXPORTS_IGNORE.includes(exportName));
+    const exportsInvalid = exportsAll.filter((e) => e !== 'default' && e !== configName);
+    if (exportsInvalid.length === 0) {
+        if (exportsAll.length === 1) {
+            return;
+        }
+        const exportDefault = pc.cyan('export default');
+        const exportNamed = pc.cyan(`export { ${configName} }`);
+        if (exportsAll.length === 0) {
+            assertUsage(false, `${filePathToShowToUser} doesn't export any value, but it should have a ${exportNamed} or ${exportDefault}`);
+        }
+        else {
+            assert(exportsAll.length === 2); // because `exportsInvalid.length === 0`
+            assertWarning(false, `${filePathToShowToUser} remove ${exportNamed} or ${exportDefault}`, {
+                onlyOnce: true
+            });
+        }
+    }
+    else {
+        if (TOLERATE_SIDE_EXPORTS.some((ext) => filePathToShowToUser.endsWith(ext)))
+            return;
+        exportsInvalid.forEach((exportInvalid) => {
+            assertWarning(false, `${filePathToShowToUser} should have only one export: move ${pc.cyan(`export { ${exportInvalid} }`)} to its own +${exportsInvalid}.js file`, { onlyOnce: true });
+        });
+    }
+}