vike 0.4.158 → 0.4.159-commit-71760c7

package/dist/cjs/utils/nodeEnv.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setNodeEnvToProduction = exports.getNodeEnv = void 0;
+exports.isNodeEnvDev = exports.setNodeEnvToProduction = exports.getNodeEnv = void 0;
 function getNodeEnv() {
     if (typeof process === 'undefined')
         return null;
@@ -14,3 +14,13 @@ function setNodeEnvToProduction() {
     env.NODE_ENV = 'production';
 }
 exports.setNodeEnvToProduction = setNodeEnvToProduction;
+function isNodeEnvDev() {
+    const nodeEnv = getNodeEnv();
+    if (!nodeEnv)
+        return true;
+    if (['development', 'dev'].includes(nodeEnv))
+        return true;
+    // That's quite aggressive, let's see if some user complains
+    return false;
+}
+exports.isNodeEnvDev = isNodeEnvDev;

package/dist/cjs/utils/projectInfo.js

@@ -2,13 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = exports.projectInfo = void 0;
 const assertSingleInstance_js_1 = require("./assertSingleInstance.js");
-const PROJECT_VERSION = '0.4.158';
+const PROJECT_VERSION = '0.4.159-commit-71760c7';
 exports.PROJECT_VERSION = PROJECT_VERSION;
 const projectInfo = {
     projectName: 'Vike',
-    projectVersion: PROJECT_VERSION,
-    npmPackageName: 'vike',
-    githubRepository: 'https://github.com/vikejs/vike'
+    projectVersion: PROJECT_VERSION
 };
 exports.projectInfo = projectInfo;
 // Trick: since `utils/asserts.ts` depends on this file (`utils/projectInfo.ts`), we can have confidence that this file is always instantiated. So that we don't have to initialize this code snippet at every possible entry. (There are a *lot* of entries: `client/router/`, `client/`, `node/`, `node/plugin/`, `node/cli`, etc.)

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

@@ -3,7 +3,7 @@ export { plugin };
 // TODO/v1-release: remove
 export { plugin as ssr };
 export { PROJECT_VERSION as version } from './utils.js';
-import { assertUsage, markEnvAsVite } from './utils.js';
+import { assertUsage, getNodeEnv, isNodeEnvDev, markEnvAsVikePluginLoaded, vikeVitePluginLoadedInProductionError } from './utils.js';
 import { buildConfig } from './plugins/buildConfig.js';
 import { previewConfig } from './plugins/previewConfig.js';
 import { autoFullBuild } from './plugins/autoFullBuild.js';
@@ -24,7 +24,8 @@ import { baseUrls } from './plugins/baseUrls.js';
 import { envVarsPlugin } from './plugins/envVars.js';
 import pc from '@brillout/picocolors';
 import { fileEnv } from './plugins/fileEnv.js';
-markEnvAsVite();
+assertNodeEnv();
+markEnvAsVikePluginLoaded();
 // Return as `any` to avoid Plugin type mismatches when there are multiple Vite versions installed
 function plugin(vikeConfig) {
     const plugins = [
@@ -64,3 +65,21 @@ Object.defineProperty(plugin, 'apply', {
         assertUsage(false, `Add ${pc.cyan('vike()')} instead of ${pc.cyan('vike')} to vite.config.js#plugins (i.e. call the function and add the return value instead of adding the function itself)`, { showStackTrace: true });
     }
 });
+function assertNodeEnv() {
+    const nodeEnv = getNodeEnv();
+    if (nodeEnv === 'test')
+        return;
+    // 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(
+    /* We can enable this assertion after Vike's CLI is implemented and using Vite's CLI is deprecated (we can then check whether the context is a `$ vike build`).
+    isNodeEnvDev() || isVikeCliBuild(),
+    /*/
+    isNodeEnvDev() || true, 
+    ///*/
+    [
+        pc.cyan(`process.env.NODE_ENV === ${JSON.stringify(nodeEnv)}`),
+        '(which Vike interprets as a non-development environment https://vike.dev/NODE_ENV)',
+        'while the vike/plugin module is loaded.',
+        vikeVitePluginLoadedInProductionError
+    ].join(' '));
+}

package/dist/esm/node/plugin/plugins/devConfig/index.js

@@ -3,7 +3,7 @@ import { determineOptimizeDeps } from './determineOptimizeDeps.js';
 import { determineFsAllowList } from './determineFsAllowList.js';
 import { getConfigVike } from '../../../shared/getConfigVike.js';
 import { addSsrMiddleware } from '../../shared/addSsrMiddleware.js';
-import { markEnvAsDev } from '../../utils.js';
+import { markEnvAsViteDev } from '../../utils.js';
 import { improveViteLogs } from '../../shared/loggerVite.js';
 import { isErrorDebug } from '../../shared/isErrorDebug.js';
 import { installHttpRequestAsyncStore } from '../../shared/getHttpRequestAsyncStore.js';
@@ -64,7 +64,7 @@ function devConfig() {
                 }
             },
             configureServer() {
-                markEnvAsDev();
+                markEnvAsViteDev();
             }
         },
         {

package/dist/esm/node/plugin/plugins/importBuild/index.js

@@ -1,6 +1,6 @@
 export { importBuild };
 import { serverEntryPlugin, findServerEntry } from '@brillout/vite-plugin-server-entry/plugin.js';
-import { assert, getOutDirs, projectInfo, toPosixPath, viteIsSSR } from '../../utils.js';
+import { assert, getOutDirs, toPosixPath, viteIsSSR } from '../../utils.js';
 import path from 'path';
 import { createRequire } from 'module';
 import { getConfigVike } from '../../../shared/getConfigVike.js';
@@ -32,7 +32,7 @@ function importBuild() {
             getImporterCode: () => {
                 return getEntryCode(config, configVike);
             },
-            libraryName: projectInfo.projectName
+            libraryName: 'Vike'
         })
     ];
 }

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getConfigFileExport.d.ts

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

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getConfigFileExport.js

@@ -0,0 +1,12 @@
+export { getConfigFileExport };
+import pc from '@brillout/picocolors';
+import { assertPlusFileExport } from '../../../../../shared/page-configs/assertPlusFileExport.js';
+import { assert, assertUsage, isObject } from '../../../utils.js';
+function getConfigFileExport(fileExports, filePathToShowToUser) {
+    assertPlusFileExport(fileExports, filePathToShowToUser, 'config');
+    const fileExport = fileExports.default || fileExports.config;
+    assert('default' in fileExports !== 'config' in fileExports);
+    const exportName = pc.cyan('default' in fileExports ? 'export default' : 'export { config }');
+    assertUsage(isObject(fileExport), `The ${exportName} of ${filePathToShowToUser} should be an object (but it's ${pc.cyan(`typeof exportedValue === ${JSON.stringify(typeof fileExport)}`)} instead)`);
+    return fileExport;
+}

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.d.ts

@@ -24,12 +24,17 @@ type ConfigDefinition = {
      */
     cumulative?: boolean;
     /**
-     * Define a so-called "Shortcut Config".
+     * Function called when the config value is defined.
      *
      * https://vike.dev/meta
      */
     effect?: ConfigEffect;
 };
+/**
+ * Function called when the config value is defined.
+ *
+ * https://vike.dev/meta
+ */
 type ConfigEffect = (config: {
     /** The config value.
      *

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js

@@ -7,17 +7,18 @@ import path from 'path';
 import { configDefinitionsBuiltIn, configDefinitionsBuiltInGlobal } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, isGlobalLocation, applyFilesystemRoutingRootEffect } from './getVikeConfig/filesystemRouting.js';
 import { isTmpFile, transpileAndExecuteFile } from './transpileAndExecuteFile.js';
-import { parseImportData } from './replaceImportStatements.js';
+import { parseImportData } from './transformImportStatements.js';
 import { isConfigInvalid, isConfigInvalid_set } from '../../../../runtime/renderPage/isConfigInvalid.js';
 import { getViteDevServer } from '../../../../runtime/globalContext.js';
 import { logConfigError, logConfigErrorRecover } from '../../../shared/loggerNotProd.js';
 import { removeSuperfluousViteLog_enable, removeSuperfluousViteLog_disable } from '../../../shared/loggerVite/removeSuperfluousViteLog.js';
 import pc from '@brillout/picocolors';
 import { getConfigDefinedAtString } from '../../../../../shared/page-configs/helpers.js';
-import { assertExportsOfConfigFile, assertExportsOfValueFile } from '../../../../../shared/page-configs/assertExports.js';
+import { assertPlusFileExport } from '../../../../../shared/page-configs/assertPlusFileExport.js';
 import { getConfigVike } from '../../../../shared/getConfigVike.js';
 import { assertConfigValueIsSerializable } from './getConfigValuesSerialized.js';
 import { crawlPlusFiles } from './getVikeConfig/crawlPlusFiles.js';
+import { getConfigFileExport } from './getConfigFileExport.js';
 assertIsNotProductionRuntime();
 let devServerIsCorrupt = false;
 let wasConfigInvalid = null;
@@ -137,7 +138,7 @@ function getConfigDefinitionOptional(configDefinitions, configName) {
 async function loadValueFile(interfaceValueFile, configName, userRootDir) {
     const { fileExports } = await transpileAndExecuteFile(interfaceValueFile.filePath, true, userRootDir);
     const { filePathToShowToUser } = interfaceValueFile.filePath;
-    assertExportsOfValueFile(fileExports, filePathToShowToUser, configName);
+    assertPlusFileExport(fileExports, filePathToShowToUser, configName);
     Object.entries(fileExports).forEach(([exportName, configValue]) => {
         const configName_ = exportName === 'default' ? configName : exportName;
         interfaceValueFile.configMap[configName_] = { configValue };
@@ -169,9 +170,8 @@ function getInterfaceFileFromConfigFile(configFile, isConfigExtend) {
         isConfigExtend,
         extendsFilePaths
     };
-    const { filePathToShowToUser } = filePath;
-    assertExportsOfConfigFile(fileExports, filePathToShowToUser);
-    Object.entries(fileExports.default).forEach(([configName, configValue]) => {
+    const fileExport = getConfigFileExport(fileExports, filePath.filePathToShowToUser);
+    Object.entries(fileExport).forEach(([configName, configValue]) => {
         interfaceFile.configMap[configName] = { configValue };
     });
     return interfaceFile;
@@ -920,18 +920,17 @@ function assertExtendsImportPath(importPath, filePath, configFilePath) {
 }
 function getExtendsImportData(configFileExports, configFilePath) {
     const { filePathToShowToUser } = configFilePath;
-    assertExportsOfConfigFile(configFileExports, filePathToShowToUser);
-    const defaultExports = configFileExports.default;
+    const configFileExport = getConfigFileExport(configFileExports, filePathToShowToUser);
     const wrongUsage = `${filePathToShowToUser} sets the config ${pc.cyan('extends')} to an invalid value, see https://vike.dev/extends`;
     let extendList;
-    if (!('extends' in defaultExports)) {
+    if (!('extends' in configFileExport)) {
         return [];
     }
-    else if (hasProp(defaultExports, 'extends', 'string')) {
-        extendList = [defaultExports.extends];
+    else if (hasProp(configFileExport, 'extends', 'string')) {
+        extendList = [configFileExport.extends];
     }
-    else if (hasProp(defaultExports, 'extends', 'string[]')) {
-        extendList = defaultExports.extends;
+    else if (hasProp(configFileExport, 'extends', 'string[]')) {
+        extendList = configFileExport.extends;
     }
     else {
         assertUsage(false, wrongUsage);

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/{replaceImportStatements.d.ts → transformImportStatements.d.ts}

@@ -1,19 +1,20 @@
-export { replaceImportStatements };
+export { transformImportStatements };
 export { parseImportData };
 export { isImportData };
 export type { FileImport };
 export type { ImportData };
+export { isVikeRealImport };
 type FileImport = {
     importStatementCode: string;
     importString: string;
     importLocalName: string;
 };
-declare function replaceImportStatements(code: string, filePathToShowToUser: string): {
-    noImportStatement: true;
+declare function transformImportStatements(code: string, filePathToShowToUser2: string): {
+    noTransformation: true;
 } | {
-    noImportStatement: false;
+    noTransformation: false;
     code: string;
-    fileImports: FileImport[];
+    fileImportsTransformed: FileImport[];
 };
 /**
  * Data Structure holding info about import statement:
@@ -41,3 +42,4 @@ declare module 'estree' {
         end: number;
     }
 }
+declare function isVikeRealImport(code: string, posStart: number): boolean;

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/{replaceImportStatements.js → transformImportStatements.js}

@@ -1,22 +1,31 @@
-export { replaceImportStatements };
+export { transformImportStatements };
 export { parseImportData };
 export { isImportData };
+// For ./transformImportStatements.spec.ts
+export { isVikeRealImport };
 // Playground: https://github.com/brillout/acorn-playground
+// Import attributes support: https://github.com/acornjs/acorn/issues/983
+//  - Isn't stage 4 yet: https://github.com/tc39/proposal-import-attributes
 import { parse } from 'acorn';
 import { assert, assertUsage, assertWarning, styleFileRE } from '../../../utils.js';
 import pc from '@brillout/picocolors';
-function replaceImportStatements(code, filePathToShowToUser) {
+function transformImportStatements(code, filePathToShowToUser2) {
     const spliceOperations = [];
-    const fileImports = [];
+    const fileImportsTransformed = [];
+    // Performance trick
+    if (!code.includes('import'))
+        return { noTransformation: true };
     const imports = getImports(code);
     if (imports.length === 0)
-        return { noImportStatement: true };
+        return { noTransformation: true };
     imports.forEach((node) => {
         if (node.type !== 'ImportDeclaration')
             return;
         const importPath = node.source.value;
         assert(typeof importPath === 'string');
         const { start, end } = node;
+        if (isVikeRealImport(code, end))
+            return;
         const importStatementCode = code.slice(start, end);
         // No variable imported
         if (node.specifiers.length === 0) {
@@ -29,7 +38,7 @@ function replaceImportStatements(code, filePathToShowToUser) {
                 quote = pc.bold(pc.red(quote));
             }
             const errMsg = [
-                `As explained in https://vike.dev/header-file the following import in ${filePathToShowToUser} has no effect:`,
+                `As explained in https://vike.dev/header-file the following import in ${filePathToShowToUser2} has no effect:`,
                 quote
             ].join('\n');
             if (!isWarning) {
@@ -57,7 +66,7 @@ function replaceImportStatements(code, filePathToShowToUser) {
             })();
             const importString = serializeImportData({ importPath, exportName, importStringWasGenerated: true });
             replacement += `const ${importLocalName} = '${importString}';`;
-            fileImports.push({
+            fileImportsTransformed.push({
                 importStatementCode,
                 importString,
                 importLocalName
@@ -70,7 +79,7 @@ function replaceImportStatements(code, filePathToShowToUser) {
         });
     });
     const codeMod = spliceMany(code, spliceOperations);
-    return { code: codeMod, fileImports, noImportStatement: false };
+    return { code: codeMod, fileImportsTransformed, noTransformation: false };
 }
 function getImports(code) {
     const { body } = parse(code, {
@@ -146,3 +155,10 @@ function indent(str) {
         .map((s) => `  ${s}`)
         .join('\n');
 }
+function isVikeRealImport(code, posStart) {
+    let posEnd = code.indexOf('\n', posStart);
+    if (posEnd === -1)
+        posEnd = code.length;
+    const lineEnd = code.slice(posStart, posEnd);
+    return lineEnd.includes('@vike-real-import');
+}

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/transpileAndExecuteFile.js

@@ -8,14 +8,14 @@ import path from 'path';
 import pc from '@brillout/picocolors';
 import { import_ } from '@brillout/import';
 import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, unique, assertWarning, isObject, toPosixPath } from '../../../utils.js';
-import { isImportData, replaceImportStatements } from './replaceImportStatements.js';
+import { isImportData, transformImportStatements } from './transformImportStatements.js';
 import { vikeConfigDependencies } from './getVikeConfig.js';
 import 'source-map-support/register.js';
-import { assertExportsOfConfigFile } from '../../../../../shared/page-configs/assertExports.js';
+import { getConfigFileExport } from './getConfigFileExport.js';
 assertIsNotProductionRuntime();
 async function transpileAndExecuteFile(filePath, isValueFile, userRootDir) {
-    const { code, fileImports } = await transpileFile(filePath, isValueFile, userRootDir);
-    const { fileExports } = await executeFile(filePath, code, fileImports, isValueFile);
+    const { code, fileImportsTransformed } = await transpileFile(filePath, isValueFile, userRootDir);
+    const { fileExports } = await executeFile(filePath, code, fileImportsTransformed, isValueFile);
     return { fileExports };
 }
 async function transpileFile(filePath, isValueFile, userRootDir) {
@@ -23,39 +23,40 @@ async function transpileFile(filePath, isValueFile, userRootDir) {
     assertPosixPath(filePathAbsoluteFilesystem);
     vikeConfigDependencies.add(filePathAbsoluteFilesystem);
     let code = await transpileWithEsbuild(filePath, isValueFile, userRootDir);
-    let fileImports = null;
+    let fileImportsTransformed = null;
     {
-        const res = transpileImports(code, filePath, isValueFile);
+        const res = transformImports(code, filePath, isValueFile);
         if (res) {
             code = res.code;
-            fileImports = res.fileImports;
+            fileImportsTransformed = res.fileImportsTransformed;
         }
     }
-    return { code, fileImports };
+    return { code, fileImportsTransformed };
 }
-function transpileImports(codeOriginal, filePath, isValueFile) {
+function transformImports(codeOriginal, filePath, isValueFile) {
     // Do we need to remove the imports?
-    const { filePathAbsoluteFilesystem, filePathToShowToUser } = filePath;
+    const { filePathAbsoluteFilesystem } = filePath;
+    const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
     assertPosixPath(filePathAbsoluteFilesystem);
     const isHeader = isHeaderFile(filePathAbsoluteFilesystem);
     const isPageConfigFile = !isValueFile;
     if (!isHeader && !isPageConfigFile) {
         return null;
     }
-    assertWarning(isPageConfigFile, `${filePathToShowToUser} is a JavaScript header file (.h.js), but JavaScript header files should only be used for +config.h.js, see https://vike.dev/header-file`, { onlyOnce: true });
+    assertWarning(isPageConfigFile, `${filePathToShowToUser2} is a JavaScript header file (.h.js), but JavaScript header files should only be used for +config.h.js, see https://vike.dev/header-file`, { onlyOnce: true });
     // Remove the imports
-    const res = replaceImportStatements(codeOriginal, filePathToShowToUser);
-    if (res.noImportStatement) {
+    const res = transformImportStatements(codeOriginal, filePathToShowToUser2);
+    if (res.noTransformation) {
         return null;
     }
-    const { code, fileImports } = res;
+    const { code, fileImportsTransformed } = res;
     if (!isHeader) {
-        const filePathCorrect = appendHeaderFileExtension(filePathToShowToUser);
-        assertWarning(false, `Rename ${filePathToShowToUser} to ${filePathCorrect}, see https://vike.dev/header-file`, {
+        const filePathCorrect = appendHeaderFileExtension(filePathToShowToUser2);
+        assertWarning(false, `Rename ${filePathToShowToUser2} to ${filePathCorrect}, see https://vike.dev/header-file`, {
             onlyOnce: true
         });
     }
-    return { code, fileImports };
+    return { code, fileImportsTransformed };
 }
 async function transpileWithEsbuild(filePath, bundle, userRootDir) {
     const entryFilePath = filePath.filePathAbsoluteFilesystem;
@@ -131,7 +132,7 @@ async function transpileWithEsbuild(filePath, bundle, userRootDir) {
     assert(typeof code === 'string');
     return code;
 }
-async function executeFile(filePath, code, fileImports, isValueFile) {
+async function executeFile(filePath, code, fileImportsTransformed, isValueFile) {
     const { filePathAbsoluteFilesystem, filePathRelativeToUserRootDir } = filePath;
     // Alternative to using a temporary file: https://github.com/vitejs/vite/pull/13269
     //  - But seems to break source maps, so I don't think it's worth it
@@ -156,10 +157,10 @@ async function executeFile(filePath, code, fileImports, isValueFile) {
     //  - import() returns `[Module: null prototype] { default: { onRenderClient: '...' }}`
     //  - We don't need this special object
     fileExports = { ...fileExports };
-    if (fileImports && !isValueFile) {
+    if (fileImportsTransformed && !isValueFile) {
         assert(filePathRelativeToUserRootDir !== undefined);
-        const filePathToShowToUser = filePathRelativeToUserRootDir ?? filePathAbsoluteFilesystem;
-        assertImportsAreReExported(fileImports, fileExports, filePathToShowToUser);
+        const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
+        assertImportsAreReExported(fileImportsTransformed, fileExports, filePathToShowToUser2);
     }
     return { fileExports };
 }
@@ -205,29 +206,29 @@ function isTmpFile(filePath) {
     const fileName = path.posix.basename(filePath);
     return fileName.startsWith(tmpPrefix);
 }
-function assertImportsAreReExported(fileImports, fileExports, filePathToShowToUser) {
-    assertExportsOfConfigFile(fileExports, filePathToShowToUser);
-    const exportedStrings = getExportedStrings(fileExports.default);
+function assertImportsAreReExported(fileImportsTransformed, fileExports, filePathToShowToUser2) {
+    const fileExport = getConfigFileExport(fileExports, filePathToShowToUser2);
+    const exportedStrings = getExportedStrings(fileExport);
     Object.values(exportedStrings).forEach((exportVal) => {
         if (typeof exportVal !== 'string')
             return;
         if (!isImportData(exportVal))
             return;
         const importString = exportVal;
-        fileImports.forEach((fileImport) => {
+        fileImportsTransformed.forEach((fileImport) => {
             if (fileImport.importString === importString) {
                 fileImport.isReExported = true;
             }
         });
     });
-    const fileImportsUnused = fileImports.filter((fi) => !fi.isReExported);
-    if (fileImportsUnused.length === 0)
+    const fileImportsTransformedUnused = fileImportsTransformed.filter((fi) => !fi.isReExported);
+    if (fileImportsTransformedUnused.length === 0)
         return;
-    const importStatements = unique(fileImportsUnused.map((fi) => fi.importStatementCode));
-    const importNamesUnused = fileImportsUnused.map((fi) => pc.cyan(fi.importLocalName)).join(', ');
-    const singular = fileImportsUnused.length === 1;
-    assertWarning(fileImportsUnused.length === 0, [
-        `${filePathToShowToUser} imports the following:`,
+    const importStatements = unique(fileImportsTransformedUnused.map((fi) => fi.importStatementCode));
+    const importNamesUnused = fileImportsTransformedUnused.map((fi) => pc.cyan(fi.importLocalName)).join(', ');
+    const singular = fileImportsTransformedUnused.length === 1;
+    assertWarning(fileImportsTransformedUnused.length === 0, [
+        `${filePathToShowToUser2} imports the following:`,
         ...importStatements.map((s) => pc.cyan(`  ${s}`)),
         `But the import${singular ? '' : 's'} ${importNamesUnused} ${singular ? "isn't" : "aren't"} re-exported at ${pc.cyan('export default { ... }')} and therefore ${singular ? 'has' : 'have'} no effect, see explanation at https://vike.dev/header-file`
     ].join('\n'), { onlyOnce: true });
@@ -269,10 +270,19 @@ function triggerPrepareStackTrace(err) {
     }
 }
 function getErrIntroMsg(operation, filePath) {
+    const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
     const msg = [
+        // prettier ignore
         pc.red(`Failed to ${operation}`),
-        pc.bold(pc.red(filePath.filePathToShowToUser)),
+        pc.bold(pc.red(filePathToShowToUser2)),
         pc.red(`because:`)
     ].join(' ');
     return msg;
 }
+/** `filePath.filePathToShowToUser` may show the import path of a package, use `filePathToShowToUser2` instead always show a file path instead. */
+function getFilePathToShowToUser2(filePath) {
+    const { filePathAbsoluteFilesystem, filePathRelativeToUserRootDir } = filePath;
+    const filePathToShowToUser2 = filePathRelativeToUserRootDir || filePathAbsoluteFilesystem;
+    assert(filePathToShowToUser2);
+    return filePathToShowToUser2;
+}

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/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/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, 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,8 @@ 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 isDevNodeEnv = 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
+    // - 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(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`);
 }

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

@@ -53,6 +53,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;

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 });
+        });
+    }
+}

package/dist/esm/shared/page-configs/serialize/parseConfigValuesImported.js

@@ -1,6 +1,6 @@
 export { parseConfigValuesImported };
 import { assert } from '../../utils.js';
-import { assertExportsOfValueFile } from '../assertExports.js';
+import { assertPlusFileExport } from '../assertPlusFileExport.js';
 function parseConfigValuesImported(configValuesImported) {
     const configValues = {};
     const addConfigValue = (configName, value, importPath, exportName) => {
@@ -21,7 +21,7 @@ function parseConfigValuesImported(configValuesImported) {
         if (configValueLoaded.isValueFile) {
             const { exportValues, importPath, configName } = configValueLoaded;
             if (configName !== 'client') {
-                assertExportsOfValueFile(exportValues, importPath, configName);
+                assertPlusFileExport(exportValues, importPath, configName);
             }
             Object.entries(exportValues).forEach(([exportName, exportValue]) => {
                 const isSideExport = exportName !== 'default'; // .md files may have "side-exports" such as `export { frontmatter }`

package/dist/esm/shared/route/abort.js

@@ -7,7 +7,7 @@ export { logAbortErrorHandled };
 export { getPageContextFromAllRewrites };
 export { AbortRender };
 export { assertNoInfiniteAbortLoop };
-import { assert, assertInfo, assertUsage, assertWarning, checkType, hasProp, isUriWithProtocol, isUserHookError, joinEnglish, objectAssign, projectInfo, truncateString } from './utils.js';
+import { assert, assertInfo, assertUsage, assertWarning, checkType, hasProp, isUriWithProtocol, isUserHookError, joinEnglish, objectAssign, truncateString } from './utils.js';
 import pc from '@brillout/picocolors';
 /**
  * Abort the rendering of the current page, and redirect the user to another URL instead.
@@ -132,7 +132,7 @@ function logAbortErrorHandled(err, isProduction, pageContext) {
 }
 function assertStatusCode(statusCode, expected, caller) {
     const expectedEnglish = joinEnglish(expected.map((s) => s.toString()), 'or');
-    assertWarning(expected.includes(statusCode), `Unepexected status code ${statusCode} passed to ${caller}(), we recommend ${expectedEnglish} instead. (Or reach out at ${projectInfo.githubRepository}/issues/1008 if you believe ${statusCode} should be added.)`, { onlyOnce: true });
+    assertWarning(expected.includes(statusCode), `Unepexected status code ${statusCode} passed to ${caller}(), we recommend ${expectedEnglish} instead. (Or reach out at https://github.com/vikejs/vike/issues/1008 if you believe ${statusCode} should be added.)`, { onlyOnce: true });
 }
 function getPageContextFromAllRewrites(pageContextsFromRewrite) {
     assertNoInfiniteLoop(pageContextsFromRewrite);