vike 0.4.224 → 0.4.225-commit-2b7971f

package/dist/cjs/client/shared/getPageContextProxyForUser.js

@@ -2,78 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPageContextProxyForUser = getPageContextProxyForUser;
 const utils_js_1 = require("../server-routing-runtime/utils.js");
-const notSerializable_js_1 = require("../../shared/notSerializable.js");
-const globalObject = (0, utils_js_1.getGlobalObject)('shared/getPageContextProxyForUser.ts', {});
-/**
- * Throw error when pageContext value isn't:
- * - serializable, or
- * - defined.
- */
+const NOT_SERIALIZABLE_js_1 = require("../../shared/NOT_SERIALIZABLE.js");
+// Throw error when pageContext value isn't serializable
 function getPageContextProxyForUser(pageContext) {
-    (0, utils_js_1.assert)([true, false].includes(pageContext._hasPageContextFromServer));
-    (0, utils_js_1.assert)([true, false].includes(pageContext._hasPageContextFromClient));
     return new Proxy(pageContext, {
         get(_, prop) {
             const val = pageContext[prop];
             const propName = (0, utils_js_1.getPropAccessNotation)(prop);
-            (0, utils_js_1.assertUsage)(val !== notSerializable_js_1.notSerializable, `Can't access pageContext${propName} on the client side. Because it can't be serialized, see server logs.`);
-            passToClientHint(pageContext, prop, propName);
+            (0, utils_js_1.assertUsage)(val !== NOT_SERIALIZABLE_js_1.NOT_SERIALIZABLE, `Can't access pageContext${propName} on the client side. Because it can't be serialized, see server logs.`);
             return val;
         }
     });
 }
-function passToClientHint(pageContext, prop, propName) {
-    if (handleVueReactivity(prop))
-        return;
-    // `prop in pageContext` is the trick we use to know the passToClient value on the client-side, as we set a value to all passToClient props, even `undefined` ones:
-    // ```html
-    // <script id="vike_pageContext" type="application/json">{"pageProps":"!undefined"}</script>
-    // ```
-    if (prop in pageContext)
-        return;
-    if (isWhitelisted(prop))
-        return;
-    // The trick described above (`prop in pageContext`) doesn't work if Vike doesn't fetch any pageContext from the server.
-    // - There would still be some value to show a warning, but it isn't worth it because of the confusion that the first recommendation (adding `prop` to `passToClient`) wouldn't actually remove the warning, and only the second recommendation (using `prop in pageContext` instead of `pageContext[prop]`) would work.
-    if (!pageContext._hasPageContextFromServer)
-        return;
-    const errMsg = `pageContext${propName} isn't defined on the client-side, see https://vike.dev/passToClient#error`;
-    if (
-    // TODO/next-major-release always make it an error.
-    // - Remove pageContext._hasPageContextFromClient logic (IIRC this is its only use case).
-    pageContext._hasPageContextFromClient) {
-        (0, utils_js_1.assertWarning)(false, errMsg, { onlyOnce: false, showStackTrace: true });
-    }
-    else {
-        (0, utils_js_1.assertUsage)(false, errMsg);
-    }
-}
-const WHITELIST = [
-    'then',
-    // Vue calls toJSON()
-    'toJSON'
-];
-function isWhitelisted(prop) {
-    if (WHITELIST.includes(prop))
-        return true;
-    if (typeof prop === 'symbol')
-        return true; // Vue tries to access some symbols
-    if (typeof prop !== 'string')
-        return true;
-    if (prop.startsWith('__v_'))
-        return true; // Vue internals upon `reactive(pageContext)`
-    return false;
-}
-// Handle Vue's reactivity.
-// When changing a reactive object:
-// - Vue tries to read its old value first. This triggers a `assertIsDefined()` failure if e.g. `pageContextReactive.routeParams = pageContextNew.routeParams` and `pageContextReactive` has no `routeParams`.
-// - Vue seems to read __v_raw before reading the property.
-function handleVueReactivity(prop) {
-    if (globalObject.prev === prop || globalObject.prev === '__v_raw')
-        return true;
-    globalObject.prev = prop;
-    window.setTimeout(() => {
-        globalObject.prev = undefined;
-    }, 0);
-    return false;
-}

package/dist/cjs/node/api/build.js

@@ -16,7 +16,7 @@ const utils_js_1 = require("./utils.js");
  * https://vike.dev/api#build
  */
 async function build(options = {}) {
-    const { viteConfigEnhanced, vikeConfig } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(options.viteConfig, 'build');
+    const { viteConfigEnhanced, vikeConfig } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(options, 'build');
     // Pass it to pluginAutoFullBuild()
     if (viteConfigEnhanced)
         viteConfigEnhanced._viteConfigEnhanced = viteConfigEnhanced;

package/dist/cjs/node/api/context.js

@@ -3,19 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isVikeCliOrApi = isVikeCliOrApi;
 exports.setContextApiOperation = setContextApiOperation;
 exports.clearContextApiOperation = clearContextApiOperation;
+exports.getApiOperation = getApiOperation;
 const utils_js_1 = require("./utils.js");
 const globalObject = (0, utils_js_1.getGlobalObject)('api/context.ts', {});
 function getApiOperation() {
-    (0, utils_js_1.assert)(globalObject.apiOperation);
-    return globalObject.apiOperation;
+    return globalObject.apiOperation ?? null;
 }
 function isVikeCliOrApi() {
     // The CLI uses the API
     return !!globalObject.apiOperation;
 }
-function setContextApiOperation(operation) {
+function setContextApiOperation(operation, options) {
     (0, utils_js_1.assert)(!globalObject.apiOperation);
-    globalObject.apiOperation = operation;
+    globalObject.apiOperation = { operation, options };
 }
 function clearContextApiOperation() {
     globalObject.apiOperation = undefined;

package/dist/cjs/node/api/dev.js

@@ -9,7 +9,7 @@ const vite_1 = require("vite");
  * https://vike.dev/api#dev
  */
 async function dev(options = {}) {
-    const { viteConfigEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(options.viteConfig, 'dev');
+    const { viteConfigEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(options, 'dev');
     const server = await (0, vite_1.createServer)(viteConfigEnhanced);
     return {
         viteServer: server,

package/dist/cjs/node/api/prepareViteApiCall.js

@@ -47,10 +47,12 @@ const path_1 = __importDefault(require("path"));
 const utils_js_1 = require("./utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const globalContext_js_1 = require("../runtime/globalContext.js");
+const getEnvVarObject_js_1 = require("../plugin/shared/getEnvVarObject.js");
 const globalObject = (0, utils_js_1.getGlobalObject)('api/prepareViteApiCall.ts', {});
-async function prepareViteApiCall(viteConfigFromOptions, operation) {
+async function prepareViteApiCall(options, operation) {
     clear();
-    (0, context_js_1.setContextApiOperation)(operation);
+    (0, context_js_1.setContextApiOperation)(operation, options);
+    const viteConfigFromOptions = options.viteConfig;
     return enhanceViteConfig(viteConfigFromOptions, operation);
 }
 // For subsequent API calls, e.g. calling prerender() after build()
@@ -59,7 +61,7 @@ function clear() {
     (0, globalContext_js_1.clearGlobalContext)();
 }
 async function enhanceViteConfig(viteConfigFromOptions, operation) {
-    const viteInfo = await getInfoFromVite(viteConfigFromOptions, operation);
+    const viteInfo = await getViteInfo(viteConfigFromOptions, operation);
     await assertViteRoot2(viteInfo.root, viteInfo.viteConfigEnhanced, operation);
     const vikeConfig = await (0, getVikeConfig_js_1.getVikeConfig2)(viteInfo.root, operation === 'dev', viteInfo.vikeVitePluginOptions);
     const viteConfigEnhanced = addViteSettingsSetByVikeConfig(viteInfo.viteConfigEnhanced, vikeConfig);
@@ -81,21 +83,30 @@ function addViteSettingsSetByVikeConfig(viteConfigEnhanced, vikeConfig) {
 }
 async function getViteRoot(operation) {
     if (!globalObject.root)
-        await getInfoFromVite(undefined, operation);
+        await getViteInfo(undefined, operation);
     (0, utils_js_1.assert)(globalObject.root);
     return globalObject.root;
 }
-async function getInfoFromVite(viteConfigFromOptions, operation) {
-    const viteConfigFromUserViteFile = await loadViteConfigFile(viteConfigFromOptions, operation);
-    const root = normalizeViteRoot(
-    // `viteConfigFromOptions.root` before `viteConfigFromUserViteFile.root` replicates Vite's precedence:
+async function getViteInfo(viteConfigFromOptions, operation) {
+    let viteConfigEnhanced = viteConfigFromOptions;
+    // Precedence:
+    //  - viteConfigFromUserEnvVar (highest precendence)
+    //  - viteConfigFromOptions
+    //  - viteConfigFromUserViteFile (lowest precendence)
+    const viteConfigFromUserEnvVar = (0, getEnvVarObject_js_1.getEnvVarObject)('VITE_CONFIG');
+    if (viteConfigFromUserEnvVar)
+        viteConfigEnhanced = (0, vite_1.mergeConfig)(viteConfigEnhanced ?? {}, viteConfigFromUserEnvVar);
+    const viteConfigFromUserViteFile = await loadViteConfigFile(viteConfigEnhanced, operation);
+    // Correct precedence, replicates Vite:
     // https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L1001
-    viteConfigFromOptions?.root ?? viteConfigFromUserViteFile?.root ?? process.cwd());
+    const viteConfigResolved = (0, vite_1.mergeConfig)(viteConfigFromUserViteFile ?? {}, viteConfigEnhanced ?? {});
+    const root = normalizeViteRoot(viteConfigResolved.root ?? process.cwd());
     globalObject.root = root;
+    // - Find options `vike(options)` set in vite.config.js
+    //   - TODO/next-major: remove
+    // - Add Vike's Vite plugin if missing
     let vikeVitePluginOptions;
-    let viteConfigEnhanced = viteConfigFromOptions;
-    // If Vike's Vite plugin is found in both viteConfigFromOptions and viteConfigFromUserViteFile then Vike will later throw an error
-    const found = findVikeVitePlugin(viteConfigFromOptions) || findVikeVitePlugin(viteConfigFromUserViteFile);
+    const found = findVikeVitePlugin(viteConfigResolved);
     if (found) {
         vikeVitePluginOptions = found.vikeVitePluginOptions;
     }
@@ -104,8 +115,8 @@ async function getInfoFromVite(viteConfigFromOptions, operation) {
         // Using a dynamic import because the script calling the Vike API may not live in the same place as vite.config.js, thus vike/plugin may resolved to two different node_modules/vike directories.
         const { plugin: vikePlugin } = await Promise.resolve().then(() => __importStar(require('../plugin/index.js')));
         viteConfigEnhanced = {
-            ...viteConfigFromOptions,
-            plugins: [...(viteConfigFromOptions?.plugins ?? []), vikePlugin()]
+            ...viteConfigEnhanced,
+            plugins: [...(viteConfigEnhanced?.plugins ?? []), vikePlugin()]
         };
         const res = findVikeVitePlugin(viteConfigEnhanced);
         (0, utils_js_1.assert)(res);

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

@@ -10,7 +10,7 @@ const prepareViteApiCall_js_1 = require("./prepareViteApiCall.js");
  * https://vike.dev/api#prerender
  */
 async function prerender(options = {}) {
-    const { viteConfigEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(options.viteConfig, 'prerender');
+    const { viteConfigEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(options, 'prerender');
     options.viteConfig = viteConfigEnhanced;
     const { viteConfig } = await (0, runPrerender_js_1.runPrerenderFromAPI)(options);
     return {

package/dist/cjs/node/api/preview.js

@@ -9,7 +9,7 @@ const vite_1 = require("vite");
  * https://vike.dev/api#preview
  */
 async function preview(options = {}) {
-    const { viteConfigEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(options.viteConfig, 'preview');
+    const { viteConfigEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(options, 'preview');
     const server = await (0, vite_1.preview)(viteConfigEnhanced);
     return {
         viteServer: server,

package/dist/cjs/node/cli/context.js

@@ -2,15 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isVikeCli = isVikeCli;
 exports.setContextCliCommand = setContextCliCommand;
+exports.getCliOptions = getCliOptions;
 const utils_js_1 = require("./utils.js");
 const globalObject = (0, utils_js_1.getGlobalObject)('cli/context.ts', {});
-function getCliCommand() {
-    return globalObject.cliCommand;
+function getCliOptions() {
+    return globalObject.cliCommand?.cliOptions ?? null;
 }
 function isVikeCli() {
     return !!globalObject.cliCommand;
 }
-function setContextCliCommand(command) {
+function setContextCliCommand(command, cliOptions) {
     (0, utils_js_1.assert)(!globalObject.cliCommand);
-    globalObject.cliCommand = command;
+    globalObject.cliCommand = { command, cliOptions };
 }

package/dist/cjs/node/cli/entry.js

@@ -43,8 +43,8 @@ const parseCli_js_1 = require("./parseCli.js");
 const context_js_1 = require("./context.js");
 cli();
 async function cli() {
-    const { command } = (0, parseCli_js_1.parseCli)();
-    (0, context_js_1.setContextCliCommand)(command);
+    const { command, cliOptions } = (0, parseCli_js_1.parseCli)();
+    (0, context_js_1.setContextCliCommand)(command, cliOptions);
     if (command === 'dev') {
         await cmdDev();
     }
@@ -66,7 +66,7 @@ async function cmdDev() {
         const info = viteServer.config.logger.info;
         const startupDurationString = picocolors_1.default.dim(`ready in ${picocolors_1.default.reset(picocolors_1.default.bold(String(Math.ceil(performance.now() - startTime))))} ms`);
         const hasExistingLogs = process.stdout.bytesWritten > 0 || process.stderr.bytesWritten > 0;
-        info(`  ${picocolors_1.default.yellow(`${picocolors_1.default.bold(utils_js_1.projectInfo.projectName)} v${utils_js_1.projectInfo.projectVersion}`)}  ${startupDurationString}\n`, {
+        info(`  ${picocolors_1.default.yellow(`${picocolors_1.default.bold('Vike')} v${utils_js_1.PROJECT_VERSION}`)}  ${startupDurationString}\n`, {
             clear: !hasExistingLogs
         });
         viteServer.printUrls();

package/dist/cjs/node/cli/parseCli.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseCli = parseCli;
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const utils_js_1 = require("./utils.js");
+const getEnvVarObject_js_1 = require("../plugin/shared/getEnvVarObject.js");
 const commands = [
     { name: 'dev', desc: 'Start development server' },
     { name: 'build', desc: 'Build for production' },
@@ -13,32 +14,59 @@ const commands = [
     { name: 'prerender', desc: 'Pre-render pages (only needed when partial.disableAutoRun is true)' }
 ];
 function parseCli() {
-    const command = (() => {
-        const firstArg = process.argv[2];
-        if (!firstArg) {
-            showHelp();
-        }
-        showHelpOrVersion(firstArg);
-        if ((0, utils_js_1.includes)(commands.map((c) => c.name), firstArg))
-            return firstArg;
-        wrongUsage(`Unknown command ${picocolors_1.default.bold(firstArg)}`);
-    })();
+    const command = getCommand();
+    const cliOptions = getCliOptions();
+    return { command, cliOptions };
+}
+function getCommand() {
+    const firstArg = process.argv[2];
+    if ((0, utils_js_1.includes)(commands.map((c) => c.name), firstArg)) {
+        return firstArg;
+    }
+    if (!firstArg)
+        showHelp();
+    showHelpOrVersion(firstArg);
+    wrongUsage(`Unknown command ${picocolors_1.default.bold(firstArg)}`);
+}
+function getCliOptions() {
+    let cliOptions = {};
+    let configNameCurrent;
+    const commitIfDefinedWithoutValue = () => {
+        if (configNameCurrent)
+            commit(true);
+    };
+    const commit = (val) => {
+        (0, utils_js_1.assert)(configNameCurrent);
+        cliOptions[configNameCurrent] = val;
+        configNameCurrent = undefined;
+    };
     for (const arg of process.argv.slice(3)) {
         showHelpOrVersion(arg);
-        wrongUsage(`Unknown option ${picocolors_1.default.bold(arg)}`);
+        if (arg.startsWith('--')) {
+            commitIfDefinedWithoutValue();
+            configNameCurrent = arg.slice('--'.length);
+        }
+        else {
+            if (!configNameCurrent)
+                wrongUsage(`Unknown option ${picocolors_1.default.bold(arg)}`);
+            commit((0, getEnvVarObject_js_1.parseJson5)(arg, `CLI option --${configNameCurrent}`));
+        }
     }
-    return { command };
+    commitIfDefinedWithoutValue();
+    return cliOptions;
 }
 function showHelp() {
     const TAB = ' '.repeat(3);
     const nameMaxLength = Math.max(...commands.map((c) => c.name.length));
     console.log([
-        `vike@${utils_js_1.projectInfo.projectVersion}`,
+        `vike@${utils_js_1.PROJECT_VERSION}`,
         '',
         'Usage:',
         ...[...commands, { name: '-v', desc: "Print Vike's installed version" }].map((c) => `  ${picocolors_1.default.dim('$')} ${picocolors_1.default.bold(`vike ${c.name}`)}${' '.repeat(nameMaxLength - c.name.length)}${TAB}${picocolors_1.default.dim(`# ${c.desc}`)}`),
         '',
-        `More infos at ${picocolors_1.default.underline('https://vike.dev/cli')}`
+        `Vike settings can be passed over the ${picocolors_1.default.cyan('VIKE_CONFIG')} environment variable or as ${picocolors_1.default.cyan('CLI options')} such as --host.`,
+        `Vite settings can be passed over the ${picocolors_1.default.cyan('VITE_CONFIG')} environment variable.`,
+        `See ${picocolors_1.default.underline('https://vike.dev/cli')} for more information.`
     ].join('\n'));
     process.exit(1);
 }
@@ -51,7 +79,7 @@ function showHelpOrVersion(arg) {
     }
 }
 function showVersion() {
-    console.log(utils_js_1.projectInfo.projectVersion);
+    console.log(utils_js_1.PROJECT_VERSION);
     process.exit(1);
 }
 function wrongUsage(msg) {

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

@@ -19,6 +19,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const onLoad_js_1 = require("./onLoad.js");
 (0, onLoad_js_1.onLoad)();
 __exportStar(require("../../utils/assert.js"), exports);
-__exportStar(require("../../utils/projectInfo.js"), exports);
+__exportStar(require("../../utils/PROJECT_VERSION.js"), exports);
 __exportStar(require("../../utils/includes.js"), exports);
 __exportStar(require("../../utils/getGlobalObject.js"), exports);

package/dist/cjs/node/plugin/plugins/build/pluginBuildEntry.js

@@ -40,7 +40,7 @@ function pluginBuildEntry() {
 function getServerProductionEntryCode(config) {
     const importPath = getImportPath(config);
     const buildInfo = {
-        versionAtBuildTime: utils_js_1.projectInfo.projectVersion,
+        versionAtBuildTime: utils_js_1.PROJECT_VERSION,
         usesClientRouter: (0, extractExportNamesPlugin_js_1.isUsingClientRouter)(), // TODO/v1-release: remove
         viteConfigRuntime: (0, globalContext_js_1.getViteConfigRuntime)(config)
     };

package/dist/cjs/node/plugin/plugins/commonConfig.js

@@ -5,14 +5,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.commonConfig = commonConfig;
 exports.getVikeConfigPublic = getVikeConfigPublic;
-const vite_1 = require("vite");
 const utils_js_1 = require("../utils.js");
 const pluginBuildConfig_js_1 = require("./build/pluginBuildConfig.js");
 const require_shim_1 = require("@brillout/require-shim");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const path_1 = __importDefault(require("path"));
 const assertResolveAlias_js_1 = require("./commonConfig/assertResolveAlias.js");
-const getEnvVarObject_js_1 = require("../shared/getEnvVarObject.js");
 const isViteCliCall_js_1 = require("../shared/isViteCliCall.js");
 const context_js_1 = require("../../api/context.js");
 const getVikeConfig_js_1 = require("./importUserCode/v1-design/getVikeConfig.js");
@@ -44,7 +42,7 @@ function commonConfig(vikeVitePluginOptions) {
                         },
                         // TODO/v1-release: remove https://github.com/vikejs/vike/issues/2122
                         configVikePromise: Promise.resolve({
-                            prerender: (0, resolvePrerenderConfig_js_1.resolvePrerenderConfigGlobal)(vikeConfig).isEnabled
+                            prerender: (0, resolvePrerenderConfig_js_1.resolvePrerenderConfigGlobal)(vikeConfig).isPrerenderingEnabled
                         })
                     };
                 }
@@ -78,17 +76,24 @@ function commonConfig(vikeVitePluginOptions) {
             config: {
                 order: 'post',
                 handler(configFromUser) {
-                    // Change default port
                     let configFromVike = { server: {}, preview: {} };
-                    setDefault('port', 3000, configFromUser, configFromVike);
-                    // Set `--host` for Docker/Podman
-                    if ((0, utils_js_1.isDocker)()) {
+                    const vike = getVikeConfigPublic(configFromUser);
+                    if (vike.config.port !== undefined) {
+                        // https://vike.dev/port
+                        setDefault('port', vike.config.port, configFromUser, configFromVike);
+                    }
+                    else {
+                        // Change Vite's default port
+                        setDefault('port', 3000, configFromUser, configFromVike);
+                    }
+                    if (vike.config.host) {
+                        // https://vike.dev/host
+                        setDefault('host', vike.config.host, configFromUser, configFromVike);
+                    }
+                    else if ((0, utils_js_1.isDocker)()) {
+                        // Set `--host` for Docker/Podman
                         setDefault('host', true, configFromUser, configFromVike);
                     }
-                    // VITE_CONFIG
-                    const configFromEnvVar = (0, getEnvVarObject_js_1.getEnvVarObject)('VITE_CONFIG');
-                    if (configFromEnvVar)
-                        configFromVike = (0, vite_1.mergeConfig)(configFromVike, configFromEnvVar);
                     return configFromVike;
                 }
             }

package/dist/cjs/node/plugin/plugins/devConfig/determineOptimizeDeps.js

@@ -52,16 +52,18 @@ async function getPageDeps(config, pageConfigs) {
                     .forEach((configValueSource) => {
                     if (!configValueSource.valueIsLoadedWithImport && !configValueSource.valueIsFilePath)
                         return;
-                    const { definedAtFilePath, configEnv } = configValueSource;
+                    const { definedAt, configEnv } = configValueSource;
                     if (!configEnv.client)
                         return;
-                    if (definedAtFilePath.filePathAbsoluteUserRootDir !== null) {
+                    if (definedAt.definedBy)
+                        return;
+                    if (definedAt.filePathAbsoluteUserRootDir !== null) {
                         // Vite expects entries to be filesystem absolute paths (surprisingly so).
-                        addEntry(definedAtFilePath.filePathAbsoluteFilesystem);
+                        addEntry(definedAt.filePathAbsoluteFilesystem);
                     }
                     else {
                         // Adding definedAtFilePath.filePathAbsoluteFilesystem doesn't work for npm packages, I guess because of Vite's config.server.fs.allow
-                        addInclude(definedAtFilePath.importPathAbsolute);
+                        addInclude(definedAt.importPathAbsolute);
                     }
                 });
             });

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

@@ -84,7 +84,7 @@ function devConfig() {
                     if (config.server.middlewareMode || hasHonoViteDevServer)
                         return;
                     return () => {
-                        (0, addSsrMiddleware_js_1.addSsrMiddleware)(server.middlewares, config, false);
+                        (0, addSsrMiddleware_js_1.addSsrMiddleware)(server.middlewares, config, false, null);
                     };
                 }
             },

package/dist/cjs/node/plugin/plugins/importUserCode/index.js

@@ -34,9 +34,9 @@ function importUserCode() {
                 return (0, virtual_files_js_1.resolveVirtualFileId)(id);
             }
         },
-        handleHotUpdate(ctx) {
+        async handleHotUpdate(ctx) {
             try {
-                return handleHotUpdate(ctx, config);
+                return await handleHotUpdate(ctx, config);
             }
             catch (err) {
                 // Vite swallows errors thrown by handleHotUpdate()
@@ -68,9 +68,9 @@ function handleFileAddRemove(server, config) {
     server.watcher.prependListener('add', (f) => listener(f, false));
     server.watcher.prependListener('unlink', (f) => listener(f, true));
     return;
-    function listener(file, isRemove) {
+    async function listener(file, isRemove) {
         file = (0, vite_1.normalizePath)(file);
-        if ((0, crawlPlusFiles_js_1.isPlusFile)(file) || isVikeConfigDependency(file, server.moduleGraph)?.modifiesVikeVirtualFiles) {
+        if ((0, crawlPlusFiles_js_1.isPlusFile)(file) || (await isVikeConfigDependency(file, server.moduleGraph))?.modifiesVikeVirtualFiles) {
             invalidateVikeVirtualFiles(server);
             reloadConfig(file, config, isRemove ? 'removed' : 'created');
         }
@@ -82,9 +82,9 @@ function invalidateVikeVirtualFiles(server) {
         server.moduleGraph.invalidateModule(mod);
     });
 }
-function handleHotUpdate(ctx, config) {
+async function handleHotUpdate(ctx, config) {
     const { file, server } = ctx;
-    const isVikeConfig = isVikeConfigDependency(ctx.file, ctx.server.moduleGraph);
+    const isVikeConfig = await isVikeConfigDependency(ctx.file, ctx.server.moduleGraph);
     if (isVikeConfig) {
         if (isVikeConfig.modifiesVikeVirtualFiles) {
             /* Tailwind breaks this assertion, see https://github.com/vikejs/vike/discussions/1330#discussioncomment-7787238
@@ -106,12 +106,16 @@ function handleHotUpdate(ctx, config) {
         }
     }
 }
-function isVikeConfigDependency(filePathAbsoluteFilesystem, moduleGraph) {
+async function isVikeConfigDependency(filePathAbsoluteFilesystem, moduleGraph) {
     // Check config-only files, for example all pages/+config.js dependencies. (There aren't part of Vite's module graph.)
     (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
-    getVikeConfig_js_1.vikeConfigDependencies.forEach((f) => (0, utils_js_1.assertPosixPath)(f));
-    if (getVikeConfig_js_1.vikeConfigDependencies.has(filePathAbsoluteFilesystem))
-        return { modifiesVikeVirtualFiles: true };
+    const vikeConfigObject = await (0, getVikeConfig_js_1.getVikeConfigOptional)();
+    if (vikeConfigObject) {
+        const { vikeConfigDependencies } = vikeConfigObject;
+        vikeConfigDependencies.forEach((f) => (0, utils_js_1.assertPosixPath)(f));
+        if (vikeConfigDependencies.has(filePathAbsoluteFilesystem))
+            return { modifiesVikeVirtualFiles: true };
+    }
     // Check using Vite's module graph, for example all +htmlAttributes dependencies.
     // Alternatively, simply call updateUserFiles() on every handleHotUpdate() call.
     const importers = getImporters(filePathAbsoluteFilesystem, moduleGraph);

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

@@ -98,7 +98,7 @@ const configDefinitionsBuiltIn = {
                     (0, utils_js_1.assert)(source.valueIsLoaded);
                     if (source.value !== null) {
                         const { value } = source;
-                        const definedAt = (0, getConfigDefinedAt_js_1.getConfigDefinedAt)('Config', 'clientHooks', source.definedAtFilePath);
+                        const definedAt = (0, getConfigDefinedAt_js_1.getConfigDefinedAt)('Config', 'clientHooks', source.definedAt);
                         (0, utils_js_1.assertUsage)(typeof value === 'boolean', `${definedAt} should be a boolean`);
                         return value;
                     }
@@ -125,6 +125,14 @@ const configDefinitionsBuiltIn = {
     cacheControl: {
         env: { server: true }
     },
+    host: {
+        env: { config: true },
+        global: true
+    },
+    port: {
+        env: { config: true },
+        global: true
+    },
     injectScriptsAt: {
         env: { server: true }
     },
@@ -150,7 +158,7 @@ const configDefinitionsBuiltIn = {
     },
     prerender: {
         env: { config: true },
-        global: (value) => typeof value === 'object',
+        global: (value, { isGlobalLocation }) => typeof value === 'object' || isGlobalLocation,
         type: ['boolean', 'object'],
         cumulative: true
     },

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

@@ -14,7 +14,6 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const import_1 = require("@brillout/import");
 const utils_js_1 = require("../../../../utils.js");
 const transformPointerImports_js_1 = require("./transformPointerImports.js");
-const getVikeConfig_js_1 = require("../getVikeConfig.js");
 const source_map_support_1 = __importDefault(require("source-map-support"));
 const getFilePath_js_1 = require("../../../../shared/getFilePath.js");
 const module_1 = require("module");
@@ -31,11 +30,11 @@ async function transpileAndExecuteFile(filePath, userRootDir, isExtensionConfig,
     const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath;
     (0, utils_js_1.assert)(filePathAbsoluteFilesystem);
     const fileExtension = getFileExtension(filePathAbsoluteFilesystem);
-    if (esbuildCache[filePathAbsoluteFilesystem]) {
-        return await esbuildCache[filePathAbsoluteFilesystem];
+    if (esbuildCache.transpileCache[filePathAbsoluteFilesystem]) {
+        return await esbuildCache.transpileCache[filePathAbsoluteFilesystem];
     }
     const { promise, resolve } = (0, utils_js_1.genPromise)();
-    esbuildCache[filePathAbsoluteFilesystem] = promise;
+    esbuildCache.transpileCache[filePathAbsoluteFilesystem] = promise;
     (0, utils_js_1.assertUsage)((0, utils_js_1.isPlainJavaScriptFile)(filePathAbsoluteFilesystem), `${filePathToShowToUserResolved} has file extension .${fileExtension} but a config file can only be a JavaScript/TypeScript file`);
     const isHeader = isHeaderFile(filePathAbsoluteFilesystem);
     if (isHeader) {
@@ -48,20 +47,20 @@ async function transpileAndExecuteFile(filePath, userRootDir, isExtensionConfig,
     }
     else {
         const transformImports = isHeader ? 'all' : true;
-        const code = await transpileFile(filePath, transformImports, userRootDir);
+        const code = await transpileFile(filePath, transformImports, userRootDir, esbuildCache);
         fileExports = await executeTranspiledFile(filePath, code);
     }
     resolve({ fileExports });
     return { fileExports };
 }
-async function transpileFile(filePath, transformImports, userRootDir) {
+async function transpileFile(filePath, transformImports, userRootDir, esbuildCache) {
     const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath;
     (0, utils_js_1.assert)(filePathAbsoluteFilesystem);
     (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
-    getVikeConfig_js_1.vikeConfigDependencies.add(filePathAbsoluteFilesystem);
+    esbuildCache.vikeConfigDependencies.add(filePathAbsoluteFilesystem);
     if (debug.isActivated)
         debug('transpile', filePathToShowToUserResolved);
-    let { code, pointerImports } = await transpileWithEsbuild(filePath, userRootDir, transformImports);
+    let { code, pointerImports } = await transpileWithEsbuild(filePath, userRootDir, transformImports, esbuildCache);
     if (debug.isActivated)
         debug(`code, post esbuild (${filePathToShowToUserResolved})`, code);
     let isImportTransformed = false;
@@ -80,7 +79,7 @@ async function transpileFile(filePath, transformImports, userRootDir) {
     }
     return code;
 }
-async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
+async function transpileWithEsbuild(filePath, userRootDir, transformImports, esbuildCache) {
     const entryFilePath = filePath.filePathAbsoluteFilesystem;
     const entryFileDir = path_1.default.posix.dirname(entryFilePath);
     const options = {
@@ -234,7 +233,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
                     // We collect the dependency `args.path` in case the bulid fails (upon build error => error is thrown => no metafile)
                     let { path } = args;
                     path = (0, utils_js_1.toPosixPath)(path);
-                    getVikeConfig_js_1.vikeConfigDependencies.add(path);
+                    esbuildCache.vikeConfigDependencies.add(path);
                     return undefined;
                 });
                 /* To exhaustively collect all dependencies upon build failure, we would also need to use onResolve().
@@ -263,7 +262,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
         filePathRelative = (0, utils_js_1.toPosixPath)(filePathRelative);
         (0, utils_js_1.assertPosixPath)(userRootDir);
         const filePathAbsoluteFilesystem = path_1.default.posix.join(userRootDir, filePathRelative);
-        getVikeConfig_js_1.vikeConfigDependencies.add(filePathAbsoluteFilesystem);
+        esbuildCache.vikeConfigDependencies.add(filePathAbsoluteFilesystem);
     });
     const code = result.outputFiles[0].text;
     (0, utils_js_1.assert)(typeof code === 'string');
@@ -335,7 +334,7 @@ function getTemporaryBuildFilePath(filePathAbsoluteFilesystem) {
     const dirname = path_1.default.posix.dirname(filePathAbsoluteFilesystem);
     const filename = path_1.default.posix.basename(filePathAbsoluteFilesystem);
     // Syntax with semicolon `build:${/*...*/}` doesn't work on Windows: https://github.com/vikejs/vike/issues/800#issuecomment-1517329455
-    const filePathTmp = path_1.default.posix.join(dirname, `${filename}.build-${(0, utils_js_1.getRandomId)(12)}.mjs`);
+    const filePathTmp = path_1.default.posix.join(dirname, `${filename}.build-${(0, utils_js_1.getRandomId)()}.mjs`);
     (0, utils_js_1.assert)(isTemporaryBuildFile(filePathTmp));
     return filePathTmp;
 }