vike 0.4.159 → 0.4.160-commit-a1101c1

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

@@ -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);

package/dist/esm/utils/assert.js

@@ -25,8 +25,8 @@ const globalObject = getGlobalObject('utils/assert.ts', {
     },
     showStackTraceList: new WeakSet()
 });
-const projectTag = `[${projectInfo.npmPackageName}]`;
-const projectTagWithVersion = `[${projectInfo.npmPackageName}@${projectInfo.projectVersion}]`;
+const projectTag = `[vike]`;
+const projectTagWithVersion = `[vike@${projectInfo.projectVersion}]`;
 const numberOfStackTraceLinesToRemove = 2;
 function assert(condition, debugInfo) {
     if (condition)
@@ -36,12 +36,11 @@ function assert(condition, debugInfo) {
             return null;
         }
         const debugInfoSerialized = typeof debugInfo === 'string' ? debugInfo : JSON.stringify(debugInfo);
-        return pc.dim(`Debug info (for ${projectInfo.projectName} maintainers; you can ignore this): ${debugInfoSerialized}`);
+        return pc.dim(`Debug info (for Vike maintainers; you can ignore this): ${debugInfoSerialized}`);
     })();
-    const link = `${projectInfo.githubRepository}/issues/new`;
     let errMsg = [
-        `You stumbled upon a bug in ${projectInfo.projectName}'s source code.`,
-        `Go to ${pc.blue(link)} and copy-paste this error. A maintainer will fix the bug (usually under 24 hours).`,
+        `You stumbled upon a Vike bug.`,
+        `Go to ${pc.blue('https://github.com/vikejs/vike/issues/new')} and copy-paste this error. A maintainer will fix the bug (usually under 24 hours).`,
         debugStr
     ]
         .filter(Boolean)

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

@@ -1,10 +1,12 @@
 export { assertIsNotProductionRuntime };
-export { markEnvAsDev };
-export { markEnvAsPreview };
-export { markEnvAsVite };
+export { markEnvAsViteDev };
+export { markEnvAsVitePreview };
+export { markEnvAsVikePluginLoaded };
 export { assertEnv };
+export { vikeVitePluginLoadedInProductionError };
+declare const vikeVitePluginLoadedInProductionError = "Loading Vike's Vite plugin (the vike/plugin module) is prohibited in production.";
 declare function assertIsNotProductionRuntime(): void | undefined;
-declare function markEnvAsDev(): void | undefined;
-declare function markEnvAsPreview(): void | undefined;
-declare function markEnvAsVite(): void;
+declare function markEnvAsViteDev(): void | undefined;
+declare function markEnvAsVitePreview(): void | undefined;
+declare function markEnvAsVikePluginLoaded(): void;
 declare function assertEnv(): void | undefined;

package/dist/esm/utils/assertIsNotProductionRuntime.js

@@ -1,41 +1,59 @@
 // Mechanism to ensure code isn't loaded by production runtime
 export { assertIsNotProductionRuntime };
-export { markEnvAsDev };
-export { markEnvAsPreview };
-export { markEnvAsVite };
+export { markEnvAsViteDev };
+export { markEnvAsVitePreview };
+export { markEnvAsVikePluginLoaded };
 export { assertEnv };
-import { assert } from './assert.js';
+export { vikeVitePluginLoadedInProductionError };
+import { assert, assertUsage } from './assert.js';
 import { assertIsNotBrowser } from './assertIsNotBrowser.js';
+import { createDebugger } from './debug.js';
 import { getGlobalObject } from './getGlobalObject.js';
 import { isVitest } from './isVitest.js';
 assertIsNotBrowser();
+const debug = createDebugger('vike:setup');
+const vikeVitePluginLoadedInProductionError = `Loading Vike's Vite plugin (the vike/plugin module) is prohibited in production.`;
 const env = getGlobalObject('utils/assertIsNotProductionRuntime.ts', {});
-// Called by *.ts that want to ensure that they aren't loaded by the server runtime in production
+// Called by Vike modules that want to ensure that they aren't loaded by the server runtime in production
 function assertIsNotProductionRuntime() {
-    env.shouldBeVite = true;
+    if (debug.isEnabled)
+        debug('assertIsNotProductionRuntime()', new Error().stack);
+    env.shouldNotBeProduction = true;
 }
 // Called by Vite hook configureServer()
-function markEnvAsDev() {
-    env.isDev = true;
+function markEnvAsViteDev() {
+    if (debug.isEnabled)
+        debug('markEnvAsViteDev()', new Error().stack);
+    env.isViteDev = true;
 }
 // Called by Vite hook configurePreviewServer()
-function markEnvAsPreview() {
-    env.isPreview = true;
+function markEnvAsVitePreview() {
+    if (debug.isEnabled)
+        debug('markEnvAsVitePreview()', new Error().stack);
+    env.isVitePreview = true;
 }
 // Called by ../node/plugin/index.ts
-function markEnvAsVite() {
-    env.isVite = true;
+function markEnvAsVikePluginLoaded() {
+    if (debug.isEnabled)
+        debug('markEnvAsVikePluginLoaded()', new Error().stack);
+    env.isVikePluginLoaded = true;
 }
 // Called by ../node/runtime/index.ts
 function assertEnv() {
+    if (debug.isEnabled)
+        debug('assertEnv()', new Error().stack);
     if (isVitest())
         return;
-    if (env.isDev || env.isPreview) {
-        assert(env.isVite);
-        assert(env.shouldBeVite);
+    const isProduction = !env.isViteDev && !env.isVitePreview;
+    if (isProduction) {
+        // Seems to be the only reliable way to assert that the user doesn't load Vike's Vite plugin in production. (The other assert() that uses process.env.NODE_ENV doesn't work if the user sets the process.env.NODE_ENV value later.)
+        assertUsage(!env.isVikePluginLoaded, vikeVitePluginLoadedInProductionError);
+        // This assert() is the main goal of this file: it ensures assertIsNotProductionRuntime()
+        assert(!env.shouldNotBeProduction);
     }
     else {
-        assert(!env.isVite);
-        assert(!env.shouldBeVite);
+        // This assert() is obious and boring
+        assert(env.shouldNotBeProduction);
+        assert(env.isVikePluginLoaded);
     }
 }

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

@@ -1,7 +1,7 @@
 export { createDebugger };
 export { isDebugEnabled };
 export type { Debug };
-type Flag = 'vike:routing' | 'vike:error' | 'vike:stream' | 'vike:log' | 'vike:virtual-files' | 'vike:outDir' | 'vike:extractExportNames' | 'vike:extractAssets' | 'vike:glob' | 'vike:pageFiles' | 'vike:stem';
+type Flag = 'vike:routing' | 'vike:error' | 'vike:stream' | 'vike:log' | 'vike:virtual-files' | 'vike:outDir' | 'vike:extractExportNames' | 'vike:extractAssets' | 'vike:glob' | 'vike:pageFiles' | 'vike:stem' | 'vike:setup';
 type Debug = ReturnType<typeof createDebugger>;
 type Options = {
     serialization?: {

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

@@ -1,4 +1,6 @@
 export { getNodeEnv };
 export { setNodeEnvToProduction };
+export { isNodeEnvDev };
 declare function getNodeEnv(): null | undefined | string;
 declare function setNodeEnvToProduction(): void | undefined;
+declare function isNodeEnvDev(): boolean;

package/dist/esm/utils/nodeEnv.js

@@ -1,5 +1,6 @@
 export { getNodeEnv };
 export { setNodeEnvToProduction };
+export { isNodeEnvDev };
 function getNodeEnv() {
     if (typeof process === 'undefined')
         return null;
@@ -11,3 +12,12 @@ function setNodeEnvToProduction() {
     const { env } = proc;
     env.NODE_ENV = 'production';
 }
+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;
+}

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

@@ -1,13 +1,7 @@
 export { projectInfo };
-export type { ProjectTag };
 export { PROJECT_VERSION };
-declare const PROJECT_VERSION: "0.4.159";
-type PackageName = typeof projectInfo.npmPackageName;
-type ProjectVersion = typeof projectInfo.projectVersion;
-type ProjectTag = `[${PackageName}]` | `[${PackageName}@${ProjectVersion}]`;
+declare const PROJECT_VERSION: "0.4.160-commit-a1101c1";
 declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.159";
-    npmPackageName: "vike";
-    githubRepository: "https://github.com/vikejs/vike";
+    projectVersion: "0.4.160-commit-a1101c1";
 };

package/dist/esm/utils/projectInfo.js

@@ -1,12 +1,10 @@
 export { projectInfo };
 export { PROJECT_VERSION };
 import { onProjectInfo } from './assertSingleInstance.js';
-const PROJECT_VERSION = '0.4.159';
+const PROJECT_VERSION = '0.4.160-commit-a1101c1';
 const projectInfo = {
     projectName: 'Vike',
-    projectVersion: PROJECT_VERSION,
-    npmPackageName: 'vike',
-    githubRepository: 'https://github.com/vikejs/vike'
+    projectVersion: PROJECT_VERSION
 };
 // 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.)
 onProjectInfo(projectInfo.projectVersion);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.159",
+  "version": "0.4.160-commit-a1101c1",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",

package/dist/cjs/shared/page-configs/assertExports.js

@@ -1,67 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertExportsOfConfigFile = exports.assertExportsOfValueFile = void 0;
-const utils_js_1 = require("../utils.js");
-const picocolors_1 = __importDefault(require("@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 assertExportsOfValueFile(fileExports, filePathToShowToUser, configName) {
-    assertExports(fileExports, filePathToShowToUser, configName);
-}
-exports.assertExportsOfValueFile = assertExportsOfValueFile;
-function assertExportsOfConfigFile(fileExports, filePathToShowToUser) {
-    assertExports(fileExports, filePathToShowToUser);
-    const exportDefault = fileExports.default;
-    (0, utils_js_1.assertUsage)((0, utils_js_1.isObject)(exportDefault), `The ${picocolors_1.default.cyan('export default')} of ${filePathToShowToUser} should be an object (but it's ${picocolors_1.default.cyan(`typeof exportDefault === ${JSON.stringify(typeof exportDefault)}`)} instead)`);
-}
-exports.assertExportsOfConfigFile = assertExportsOfConfigFile;
-function assertExports(fileExports, filePathToShowToUser, configName) {
-    const exportsAll = Object.keys(fileExports);
-    const exportsRelevant = exportsAll.filter((exportName) => !EXPORTS_IGNORE.includes(exportName));
-    const exportsInvalid = exportsRelevant.filter((e) => e !== 'default' &&
-        // !!configName => isValueFile
-        e !== configName);
-    if (exportsInvalid.length === 0) {
-        if (exportsRelevant.length === 1) {
-            return;
-        }
-        const exportDefault = picocolors_1.default.cyan('export default');
-        const exportConfigName = picocolors_1.default.cyan(`export { ${configName} }`);
-        if (exportsRelevant.length === 0) {
-            let errMsg = `${filePathToShowToUser} doesn't export any value, but it should have a ${exportDefault}`;
-            if (configName)
-                errMsg += ` or ${exportConfigName}`;
-            (0, utils_js_1.assertUsage)(false, errMsg);
-        }
-        else {
-            (0, utils_js_1.assert)(exportsRelevant.length === 2);
-            (0, utils_js_1.assertWarning)(false, `${filePathToShowToUser} remove ${exportConfigName} or ${exportDefault}`, {
-                onlyOnce: true
-            });
-        }
-    }
-    else {
-        // !configName => isConfigFile
-        if (!configName) {
-            const exportsInvalidStr = exportsInvalid.join(', ');
-            (0, utils_js_1.assertUsage)(false, `${filePathToShowToUser} replace ${picocolors_1.default.cyan(`export { ${exportsInvalidStr} }`)} with ${picocolors_1.default.cyan(`export default { ${exportsInvalidStr} }`)}`);
-        }
-        // !!configName => isValueFile
-        else {
-            if (TOLERATE_SIDE_EXPORTS.some((ext) => filePathToShowToUser.endsWith(ext)))
-                return;
-            exportsInvalid.forEach((exportInvalid) => {
-                (0, utils_js_1.assertWarning)(false, `${filePathToShowToUser} should have only a single export: move ${picocolors_1.default.cyan(`export { ${exportInvalid} }`)} to +config.h.js or its own +${exportsInvalid}.js`, { onlyOnce: true });
-            });
-        }
-    }
-}

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

@@ -1,6 +0,0 @@
-export { assertExportsOfValueFile };
-export { assertExportsOfConfigFile };
-declare function assertExportsOfValueFile(fileExports: Record<string, unknown>, filePathToShowToUser: string, configName: string): void;
-declare function assertExportsOfConfigFile(fileExports: Record<string, unknown>, filePathToShowToUser: string): asserts fileExports is {
-    default: Record<string, unknown>;
-};

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

@@ -1,61 +0,0 @@
-export { assertExportsOfValueFile };
-export { assertExportsOfConfigFile };
-import { assert, assertUsage, assertWarning, isObject } 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 assertExportsOfValueFile(fileExports, filePathToShowToUser, configName) {
-    assertExports(fileExports, filePathToShowToUser, configName);
-}
-function assertExportsOfConfigFile(fileExports, filePathToShowToUser) {
-    assertExports(fileExports, filePathToShowToUser);
-    const exportDefault = fileExports.default;
-    assertUsage(isObject(exportDefault), `The ${pc.cyan('export default')} of ${filePathToShowToUser} should be an object (but it's ${pc.cyan(`typeof exportDefault === ${JSON.stringify(typeof exportDefault)}`)} instead)`);
-}
-function assertExports(fileExports, filePathToShowToUser, configName) {
-    const exportsAll = Object.keys(fileExports);
-    const exportsRelevant = exportsAll.filter((exportName) => !EXPORTS_IGNORE.includes(exportName));
-    const exportsInvalid = exportsRelevant.filter((e) => e !== 'default' &&
-        // !!configName => isValueFile
-        e !== configName);
-    if (exportsInvalid.length === 0) {
-        if (exportsRelevant.length === 1) {
-            return;
-        }
-        const exportDefault = pc.cyan('export default');
-        const exportConfigName = pc.cyan(`export { ${configName} }`);
-        if (exportsRelevant.length === 0) {
-            let errMsg = `${filePathToShowToUser} doesn't export any value, but it should have a ${exportDefault}`;
-            if (configName)
-                errMsg += ` or ${exportConfigName}`;
-            assertUsage(false, errMsg);
-        }
-        else {
-            assert(exportsRelevant.length === 2);
-            assertWarning(false, `${filePathToShowToUser} remove ${exportConfigName} or ${exportDefault}`, {
-                onlyOnce: true
-            });
-        }
-    }
-    else {
-        // !configName => isConfigFile
-        if (!configName) {
-            const exportsInvalidStr = exportsInvalid.join(', ');
-            assertUsage(false, `${filePathToShowToUser} replace ${pc.cyan(`export { ${exportsInvalidStr} }`)} with ${pc.cyan(`export default { ${exportsInvalidStr} }`)}`);
-        }
-        // !!configName => isValueFile
-        else {
-            if (TOLERATE_SIDE_EXPORTS.some((ext) => filePathToShowToUser.endsWith(ext)))
-                return;
-            exportsInvalid.forEach((exportInvalid) => {
-                assertWarning(false, `${filePathToShowToUser} should have only a single export: move ${pc.cyan(`export { ${exportInvalid} }`)} to +config.h.js or its own +${exportsInvalid}.js`, { onlyOnce: true });
-            });
-        }
-    }
-}