vike 0.4.171 → 0.4.172-commit-ea2b76c

package/dist/esm/client/client-routing-runtime/createPageContext.js

@@ -1,9 +1,9 @@
 export { createPageContext };
-import { addUrlComputedProps } from '../../shared/addUrlComputedProps.js';
+import { getPageContextUrlComputed } from '../../shared/getPageContextUrlComputed.js';
 import { getPageFilesAll } from '../../shared/getPageFiles.js';
 import { loadPageRoutes } from '../../shared/route/loadPageRoutes.js';
 import { getBaseServer } from './getBaseServer.js';
-import { assert, isBaseServer, getGlobalObject } from './utils.js';
+import { assert, isBaseServer, getGlobalObject, objectAssign } from './utils.js';
 const globalObject = getGlobalObject('createPageContext.ts', {});
 async function createPageContext(urlOriginal) {
     if (!globalObject.pageFilesData) {
@@ -26,6 +26,7 @@ async function createPageContext(urlOriginal) {
         _pageRoutes: pageRoutes,
         _onBeforeRouteHook: onBeforeRouteHook
     };
-    addUrlComputedProps(pageContext);
+    const pageContextUrlComputed = getPageContextUrlComputed(pageContext);
+    objectAssign(pageContext, pageContextUrlComputed);
     return pageContext;
 }

package/dist/esm/client/client-routing-runtime/getPageContextFromHooks.js

@@ -10,7 +10,7 @@ import { preparePageContextForUserConsumptionClientSide } from '../shared/prepar
 import { removeBuiltInOverrides } from './getPageContext/removeBuiltInOverrides.js';
 import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl.js';
 import { getPageConfig } from '../../shared/page-configs/helpers.js';
-import { getConfigValue } from '../../shared/page-configs/getConfigValue.js';
+import { getConfigValueRuntime } from '../../shared/page-configs/getConfigValue.js';
 import { assertOnBeforeRenderHookReturn } from '../../shared/assertOnBeforeRenderHookReturn.js';
 import { executeGuardHook } from '../../shared/route/executeGuardHook.js';
 import { AbortRender, isAbortPageContext } from '../../shared/route/abort.js';
@@ -32,7 +32,9 @@ async function getPageContextFromHooks_isHydration(pageContext) {
         _hasPageContextFromServer: true
     };
     for (const hookName of ['data', 'onBeforeRender']) {
-        const pageContextForHook = { ...pageContext, ...pageContextFromHooks };
+        const pageContextForHook = {};
+        objectAssign(pageContextForHook, pageContext);
+        objectAssign(pageContextForHook, pageContextFromHooks);
         if (hookClientOnlyExists(hookName, pageContextForHook)) {
             const pageContextFromHook = await executeHookClientSide(hookName, pageContextForHook);
             Object.assign(pageContextFromHooks, pageContextFromHook);
@@ -45,6 +47,9 @@ async function getPageContextFromHooks_isNotHydration(pageContext, isErrorPage)
         isHydration: false,
         _hasPageContextFromClient: false
     };
+    const pageContextForCondition = {};
+    objectAssign(pageContextForCondition, pageContext);
+    objectAssign(pageContextForCondition, pageContextFromHooks);
     let hasPageContextFromServer = false;
     // If pageContextInit has some client data or if one of the hooks guard(), data() or onBeforeRender() is server-side
     // only, then we need to fetch pageContext from the server.
@@ -53,7 +58,7 @@ async function getPageContextFromHooks_isNotHydration(pageContext, isErrorPage)
     // For the error page, we cannot fetch pageContext from the server because the pageContext JSON request is based on the URL
     !isErrorPage &&
         // true if pageContextInit has some client data or at least one of the data() and onBeforeRender() hooks is server-side only:
-        (await hasPageContextServer({ ...pageContext, ...pageContextFromHooks }))) {
+        (await hasPageContextServer(pageContextForCondition))) {
         const res = await fetchPageContextFromServer(pageContext);
         if ('is404ServerSideRouted' in res)
             return { is404ServerSideRouted: true };
@@ -70,11 +75,10 @@ async function getPageContextFromHooks_isNotHydration(pageContext, isErrorPage)
     // Note: for the error page, we also execute the client-side data() and onBeforeRender() hooks, but maybe we
     // shouldn't? The server-side does it as well (but maybe it shouldn't).
     for (const hookName of ['guard', 'data', 'onBeforeRender']) {
-        const pageContextForHook = {
-            _hasPageContextFromServer: hasPageContextFromServer,
-            ...pageContext,
-            ...pageContextFromHooks
-        };
+        const pageContextForHook = {};
+        objectAssign(pageContextForHook, { _hasPageContextFromServer: hasPageContextFromServer });
+        objectAssign(pageContextForHook, pageContext);
+        objectAssign(pageContextForHook, pageContextFromHooks);
         if (hookName === 'guard') {
             if (!isErrorPage &&
                 // We don't need to call guard() on the client-side if we fetch pageContext from the server side. (Because the `${url}.pageContext.json` HTTP request will already trigger the routing and guard() hook on the server-side.)
@@ -108,7 +112,7 @@ async function executeHookClientSide(hookName, pageContext) {
         return null;
     }
     const pageContextForUserConsumption = preparePageContextForUserConsumptionClientSide(pageContext, true);
-    const hookResult = await executeHook(() => hook.hookFn(pageContextForUserConsumption), hook);
+    const hookResult = await executeHook(() => hook.hookFn(pageContextForUserConsumption), hook, pageContext);
     const pageContextFromHook = {};
     if (hookName === 'onBeforeRender') {
         assertOnBeforeRenderHookReturn(hookResult, hook.hookFilePath);
@@ -165,7 +169,7 @@ async function hookServerOnlyExists(hookName, pageContext) {
     if (pageContext._pageConfigs.length > 0) {
         // V1
         const pageConfig = getPageConfig(pageContext._pageId, pageContext._pageConfigs);
-        const hookEnv = getConfigValue(pageConfig, `${hookName}Env`)?.value ?? {};
+        const hookEnv = getConfigValueRuntime(pageConfig, `${hookName}Env`)?.value ?? {};
         assert(isObject(hookEnv));
         return !!hookEnv.server && !hookEnv.client;
     }
@@ -189,7 +193,7 @@ function hookClientOnlyExists(hookName, pageContext) {
     if (pageContext._pageConfigs.length > 0) {
         // V1
         const pageConfig = getPageConfig(pageContext._pageId, pageContext._pageConfigs);
-        const hookEnv = getConfigValue(pageConfig, `${hookName}Env`)?.value ?? {};
+        const hookEnv = getConfigValueRuntime(pageConfig, `${hookName}Env`)?.value ?? {};
         assert(isObject(hookEnv));
         return !!hookEnv.client && !hookEnv.server;
     }
@@ -221,7 +225,7 @@ async function fetchPageContextFromServer(pageContext) {
     }
     // Is there a reason for having two different properties? Can't we use only one property? I guess/think the isServerSideError property was an attempt (a bad idea really) for rendering the error page even though an error occured on the server-side (which is a bad idea because the added complexity is non-negligible while the added value is minuscule since the error page usually doesn't have any (meaningful / server-side) hooks).
     if ('serverSideError' in pageContextFromServer || isServerSideError in pageContextFromServer) {
-        throw getProjectError(`The pageContext object couldn't be fetched from the server as an error occurred on the server-side. Check your server logs.`);
+        throw getProjectError(`pageContext couldn't be fetched from server: an error occurred on the server-side (see your server logs)`);
     }
     assert(hasProp(pageContextFromServer, '_pageId', 'string'));
     processPageContextFromServer(pageContextFromServer);

package/dist/esm/client/client-routing-runtime/installClientRouter.js

@@ -7,22 +7,30 @@ import { onLinkClick } from './onLinkClick.js';
 import { setupNativeScrollRestoration } from './scrollRestoration.js';
 import { autoSaveScrollPosition } from './setScrollPosition.js';
 async function installClientRouter() {
-    setupNativeScrollRestoration();
-    initHistoryState();
-    autoSaveScrollPosition();
-    monkeyPatchHistoryPushState();
-    // First initial render
+    // Init navigation history and scroll restoration
+    initHistoryAndScroll();
+    // Render initial page
+    const renderPromise = render();
+    // Intercept <a> clicks
+    onLinkClick();
+    // Preserve stack track
+    await renderPromise;
+}
+function render() {
     assert(getRenderCount() === 0);
-    const promise = renderPageClientSide({
+    const renderPromise = renderPageClientSide({
         scrollTarget: 'preserve-scroll',
         isBackwardNavigation: null,
         isClientSideNavigation: false
     });
     assert(getRenderCount() === 1);
-    // Intercept <a> links
-    onLinkClick();
+    return renderPromise;
+}
+function initHistoryAndScroll() {
+    setupNativeScrollRestoration();
+    initHistoryState();
+    autoSaveScrollPosition();
+    monkeyPatchHistoryPushState();
     // Handle back-/forward navigation
     onBrowserHistoryNavigation();
-    // Only for full stack straces
-    await promise;
 }

package/dist/esm/client/client-routing-runtime/renderPageClientSide.js

@@ -51,7 +51,7 @@ async function renderPageClientSide(renderArgs) {
                     const hook = onPageTransitionStartHook;
                     const { hookFn } = hook;
                     try {
-                        await executeHook(() => hookFn(pageContext), hook);
+                        await executeHook(() => hookFn(pageContext), hook, pageContext);
                     }
                     catch (err) {
                         await onError(err);
@@ -353,7 +353,7 @@ async function renderPageClientSide(renderArgs) {
             if (hook) {
                 const { hookFn } = hook;
                 try {
-                    await executeHook(() => hookFn(pageContext), hook);
+                    await executeHook(() => hookFn(pageContext), hook, pageContext);
                 }
                 catch (err) {
                     await onError(err);
@@ -377,7 +377,7 @@ async function renderPageClientSide(renderArgs) {
             if (hook) {
                 const { hookFn } = hook;
                 try {
-                    await executeHook(() => hookFn(pageContext), hook);
+                    await executeHook(() => hookFn(pageContext), hook, pageContext);
                 }
                 catch (err) {
                     await onError(err);

package/dist/esm/client/server-routing-runtime/getPageContext.d.ts

@@ -8,8 +8,8 @@ declare function getPageContext(): Promise<{
     _hasPageContextFromServer: true;
     _hasPageContextFromClient: false;
 } & {
-    _pageFilesAll: import("../../shared/getPageFiles/getPageFileObject.js").PageFile[];
-    _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
-} & import("../../shared/getPageFiles/getExports.js").PageContextExports & {
-    _pageFilesLoaded: import("../../shared/getPageFiles/getPageFileObject.js").PageFile[];
+    _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+    _pageConfigs: import("../../__internal/index.js").PageConfig[];
+} & import("../../shared/getPageFiles.js").PageContextExports & {
+    _pageFilesLoaded: import("../../shared/getPageFiles.js").PageFile[];
 }>;

package/dist/esm/client/server-routing-runtime/utils.d.ts

@@ -12,3 +12,4 @@ export * from '../../utils/parseUrl.js';
 export * from '../../utils/projectInfo.js';
 export * from '../../utils/slice.js';
 export * from '../../utils/unique.js';
+export * from '../../utils/getPropAccessNotation.js';

package/dist/esm/client/server-routing-runtime/utils.js

@@ -16,3 +16,4 @@ export * from '../../utils/parseUrl.js';
 export * from '../../utils/projectInfo.js';
 export * from '../../utils/slice.js';
 export * from '../../utils/unique.js'; // Only used by Server Routing (not needed for Client Routing)
+export * from '../../utils/getPropAccessNotation.js';

package/dist/esm/client/shared/executeOnRenderClientHook.js

@@ -45,7 +45,7 @@ async function executeOnRenderClientHook(pageContext, isClientRouting) {
     const renderHook = hook.hookFn;
     assert(hookName);
     // We don't use a try-catch wrapper because rendering errors are usually handled by the UI framework. (E.g. React's Error Boundaries.)
-    const hookResult = await executeHook(() => renderHook(pageContextForUserConsumption), hook);
+    const hookResult = await executeHook(() => renderHook(pageContextForUserConsumption), hook, pageContext);
     assertUsage(hookResult === undefined, `The ${hookName}() hook defined by ${hook.hookFilePath} isn't allowed to return a value`);
 }
 function getUrlToShowToUser(pageContext) {

package/dist/esm/client/shared/getPageContextProxyForUser.d.ts

@@ -5,7 +5,8 @@ type PageContextForPassToClientWarning = {
     _hasPageContextFromClient: boolean;
 };
 /**
- * - Throw error when pageContext value isn't serializable
- * - Throw error when pageContext prop is missing in passToClient
+ * Throw error when pageContext value isn't:
+ * - serializable, or
+ * - defined.
  */
 declare function getPageContextProxyForUser<PageContext extends Record<string, unknown> & PageContextForPassToClientWarning>(pageContext: PageContext): PageContext;

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

@@ -1,10 +1,11 @@
 export { getPageContextProxyForUser };
-import { assert, assertUsage, assertWarning, getGlobalObject } from '../server-routing-runtime/utils.js';
+import { assert, assertUsage, assertWarning, getGlobalObject, getPropAccessNotation } from '../server-routing-runtime/utils.js';
 import { notSerializable } from '../../shared/notSerializable.js';
 const globalObject = getGlobalObject('getPageContextProxyForUser.ts', {});
 /**
- * - Throw error when pageContext value isn't serializable
- * - Throw error when pageContext prop is missing in passToClient
+ * Throw error when pageContext value isn't:
+ * - serializable, or
+ * - defined.
  */
 function getPageContextProxyForUser(pageContext) {
     assert([true, false].includes(pageContext._hasPageContextFromServer));
@@ -12,66 +13,45 @@ function getPageContextProxyForUser(pageContext) {
     return new Proxy(pageContext, {
         get(_, prop) {
             const val = pageContext[prop];
-            const propName = JSON.stringify(prop);
-            assertUsage(val !== notSerializable, `pageContext[${propName}] couldn't be serialized and, therefore, is missing on the client-side. Check the server logs for more information.`);
-            assertIsDefined(pageContext, prop);
+            const propName = getPropAccessNotation(prop);
+            assertUsage(val !== notSerializable, `pageContext${propName} couldn't be serialized and, therefore, is missing on the client-side. Check the server logs for more information.`);
+            passToClientHint(pageContext, prop, propName);
             return val;
         }
     });
 }
-function assertIsDefined(pageContext, prop) {
-    // We disable assertIsDefined() for the next attempt to read `prop`, because of how Vue's reactivity work. When changing a reactive object:
-    //  - Vue tries to read its old value first. This triggers a `assertIsDefined()` failure if e.g. `pageContextOldReactive.routeParams = pageContextNew.routeParams` and `pageContextOldReactive` has no `routeParams`.
-    //  - Vue seems to read __v_raw before reading the property
-    if (globalObject.prev === prop || globalObject.prev === '__v_raw')
+function passToClientHint(pageContext, prop, propName) {
+    if (handleVueReactivity(prop))
         return;
-    ignoreNextRead(prop);
+    // `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 (isExpected(prop))
+    if (isWhitelisted(prop))
         return;
-    // - If no pageContext was fetchd from the server, then adding props to passToClient is useless.
-    // - Showing a warning, even though no pageContext was fetched from the server, is actually erroneous as the client runtime cannot deduce the passToClient list.
+    // 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 propName = JSON.stringify(prop);
-    /* This handling would be the clearest but, unfortunately, it's fundamentally problematic:
-     *  - It would force the pageContext value consumer to be synchronized with the pageContext value provider. For example, if vike-react wants to conditionally do something dependening on wehther some optional pageContext value was provided by some optional vike-react-* integration package.
-     *  - If a pageContext value is set by an optional hook, then it's expected that the value is undefined if the hook doesn't exist.
-    const errMsg = `pageContext[${propName}] is \`undefined\` on the client-side. If it's defined on the server-side then add ${propName} to passToClient (https://vike.dev/passToClient), otherwise make sure your client-side hooks always define it (e.g. set it to \`null\` instead of \`undefined\`).`
-    assertUsage(false, errMsg)
-    */
-    if (!pageContext._hasPageContextFromClient) {
-        // We can safely assume that the property is missing in passToClient, because the server-side defines all passToClient properties even if they have an undefined value:
-        // ```
-        // <script id="vike_pageContext" type="application/json">{"_pageId":"/pages/admin","user":"!undefined","pageProps":"!undefined","title":"!undefined","abortReason":"!undefined","_urlRewrite":null}</script>
-        // ```
-        // Note how properties have "!undefined" values => we can tell whether an undefined pageContext value exists in passToClient.
-        assertUsage(false, `pageContext[${propName}] isn't available on the client-side because ${propName} is missing in passToClient, see https://vike.dev/passToClient`);
+    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) {
+        assertWarning(false, errMsg, { onlyOnce: false, showStackTrace: true });
     }
     else {
-        // Do nothing, not even a warning, because we don't know whether the user expects that the pageContext value can be undefined. (E.g. a pageContext value that is defined by an optional hook.)
-        // TODO/next-major-release make it an assertUsage()
-        assertWarning(false, [
-            `pageContext[${propName}] isn't defined on the client-side:`,
-            `1. if it's defined by the server-side then add ${propName} to passToClient (https://vike.dev/passToClient), or`,
-            `2. if it's expected that it may not be defined:`,
-            '   ```js',
-            '   // ❌ Replace code like this:',
-            `   const val = pageContext[${propName}] ?? someDefaultValue`,
-            '   // ✅ With that:',
-            `   const val = ${propName} in pageContext ? pageContext[${propName}] : someDefaultValue`,
-            '   ```',
-            `See stack track below to find where pageContext[${propName}] is being accessed.`
-        ].join('\n'), { showStackTrace: true, onlyOnce: false });
+        assertUsage(false, errMsg);
     }
 }
-const IGNORE_LIST = [
+const WHITELIST = [
     'then',
-    'toJSON' // Vue tries to get `toJSON`
+    'toJSON' // Vue triggers `toJSON`
 ];
-function isExpected(prop) {
-    if (IGNORE_LIST.includes(prop))
+function isWhitelisted(prop) {
+    if (WHITELIST.includes(prop))
         return true;
     if (typeof prop === 'symbol')
         return true; // Vue tries to access some symbols
@@ -81,9 +61,16 @@ function isExpected(prop) {
         return true; // Vue internals upon `reactive(pageContext)`
     return false;
 }
-function ignoreNextRead(prop) {
+// 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/esm/client/shared/loadUserFilesClientSide.js

@@ -3,6 +3,7 @@ export { isErrorFetchingStaticAssets };
 import { getPageFilesClientSide, getPageContextExports } from '../../shared/getPageFiles.js';
 import { findPageConfig } from '../../shared/page-configs/findPageConfig.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
+import { objectAssign } from '../server-routing-runtime/utils.js';
 const stamp = '__whileFetchingAssets';
 async function loadUserFilesClientSide(pageId, pageFilesAll, pageConfigs) {
     const pageFilesClientSide = getPageFilesClientSide(pageFilesAll, pageId);
@@ -29,10 +30,9 @@ async function loadUserFilesClientSide(pageId, pageFilesAll, pageConfigs) {
         throw err;
     }
     const pageContextExports = getPageContextExports(pageFilesClientSide, pageConfigLoaded);
-    const pageContextAddendum = {
-        ...pageContextExports,
-        _pageFilesLoaded: pageFilesClientSide
-    };
+    const pageContextAddendum = {};
+    objectAssign(pageContextAddendum, pageContextExports);
+    objectAssign(pageContextAddendum, { _pageFilesLoaded: pageFilesClientSide });
     return pageContextAddendum;
 }
 function isErrorFetchingStaticAssets(err) {

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

@@ -4,19 +4,18 @@ export { analyzeClientEntries };
 export { manifestTempFile };
 import { assert, resolveOutDir, viteIsSSR, addOnBeforeLogHook, removeFileExtention, unique, assertUsage, injectRollupInputs, normalizeRollupInput, getOutDirs, assertNodeEnv_build, assertIsNpmPackageImport } from '../utils.js';
 import { getVikeConfig, isV1Design } from './importUserCode/v1-design/getVikeConfig.js';
-import { getConfigValue } from '../../../shared/page-configs/getConfigValue.js';
 import { findPageFiles } from '../shared/findPageFiles.js';
 import { getConfigVike } from '../../shared/getConfigVike.js';
 import { getVirtualFileIdPageConfigValuesAll } from '../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { extractAssetsAddQuery } from '../../shared/extractAssetsQuery.js';
 import { createRequire } from 'module';
-import { getClientEntry } from '../../shared/getClientEntry.js';
 import fs from 'fs/promises';
 import path from 'path';
 import { fixServerAssets, fixServerAssets_isEnabled } from './buildConfig/fixServerAssets.js';
 import { set_constant_ASSETS_MAP } from './importBuild/index.js';
 import { prependEntriesDir } from '../../shared/prependEntriesDir.js';
 import { getFilePathResolved } from '../shared/getFilePath.js';
+import { getConfigValueBuildTime } from '../../../shared/page-configs/getConfigValueBuildTime.js';
 // @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = import.meta.url;
 const require_ = createRequire(importMetaUrl);
@@ -152,7 +151,7 @@ function analyzeClientEntries(pageConfigs, config) {
     let clientEntries = {};
     let clientEntryList = [];
     pageConfigs.forEach((pageConfig) => {
-        const configValue = getConfigValue(pageConfig, 'clientRouting', 'boolean');
+        const configValue = getConfigValueBuildTime(pageConfig, 'clientRouting', 'boolean');
         if (configValue?.value) {
             hasClientRouting = true;
         }
@@ -165,7 +164,7 @@ function analyzeClientEntries(pageConfigs, config) {
             clientEntries[entryName] = entryTarget;
         }
         {
-            const clientEntry = getClientEntry(pageConfig);
+            const clientEntry = getConfigValueBuildTime(pageConfig, 'client', 'string')?.value ?? null;
             if (clientEntry) {
                 clientEntryList.push(clientEntry);
             }

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

@@ -2,7 +2,6 @@ export { determineOptimizeDeps };
 import { findPageFiles } from '../../shared/findPageFiles.js';
 import { assert, assertIsNpmPackageImport, createDebugger, isArray, unique } from '../../utils.js';
 import { getVikeConfig } from '../importUserCode/v1-design/getVikeConfig.js';
-import { getConfigValueSourcesNotOverriden } from '../../shared/getConfigValueSourcesNotOverriden.js';
 import { analyzeClientEntries } from '../buildConfig.js';
 import { virtualFileIdImportUserCodeClientCR, virtualFileIdImportUserCodeClientSR } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
 import { getFilePathResolved } from '../../shared/getFilePath.js';
@@ -45,20 +44,24 @@ async function getPageDeps(config, pageConfigs, isDev) {
     // V1 design
     {
         pageConfigs.forEach((pageConfig) => {
-            getConfigValueSourcesNotOverriden(pageConfig).forEach((configValueSource) => {
-                if (!configValueSource.valueIsImportedAtRuntime)
-                    return;
-                const { definedAtFilePath, configEnv } = configValueSource;
-                if (!configEnv.client)
-                    return;
-                if (definedAtFilePath.filePathAbsoluteUserRootDir !== null) {
-                    // Vite expects entries to be filesystem absolute paths (surprisingly so).
-                    addEntry(definedAtFilePath.filePathAbsoluteFilesystem);
-                }
-                else {
-                    // Adding definedAtFilePath.filePathAbsoluteFilesystem doesn't work for npm packages, I guess because of Vite's config.server.fs.allow
-                    addInclude(definedAtFilePath.importPathAbsolute);
-                }
+            Object.values(pageConfig.configValueSources).forEach((sources) => {
+                sources
+                    .filter((c) => !c.isOverriden)
+                    .forEach((configValueSource) => {
+                    if (!configValueSource.valueIsImportedAtRuntime)
+                        return;
+                    const { definedAtFilePath, configEnv } = configValueSource;
+                    if (!configEnv.client)
+                        return;
+                    if (definedAtFilePath.filePathAbsoluteUserRootDir !== null) {
+                        // Vite expects entries to be filesystem absolute paths (surprisingly so).
+                        addEntry(definedAtFilePath.filePathAbsoluteFilesystem);
+                    }
+                    else {
+                        // Adding definedAtFilePath.filePathAbsoluteFilesystem doesn't work for npm packages, I guess because of Vite's config.server.fs.allow
+                        addInclude(definedAtFilePath.importPathAbsolute);
+                    }
+                });
             });
         });
     }

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

@@ -73,7 +73,8 @@ function devConfig() {
             configureServer: {
                 order: 'post',
                 handler(server) {
-                    if (config.server.middlewareMode)
+                    const hasHonoViteDevServer = !!config.plugins.find((p) => p.name === '@hono/vite-dev-server');
+                    if (config.server.middlewareMode || hasHonoViteDevServer)
                         return;
                     return () => {
                         addSsrMiddleware(server.middlewares);

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

@@ -50,7 +50,8 @@ function envVarsPlugin() {
                             assertUsage(false, errMsg);
                         }
                         else {
-                            // Only a warning for faster development DX (e.g. when user toggles `ssr: boolean` or `onBeforeRenderIsomorph: boolean`)
+                            // - Only a warning for faster development DX (e.g. when user toggles `ssr: boolean` or `onBeforeRenderIsomorph: boolean`).
+                            // - But only showing a warning can be confusing: https://github.com/vikejs/vike/issues/1641
                             assertWarning(false, errMsg, { onlyOnce: true });
                         }
                     }

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

@@ -101,7 +101,7 @@ function extractAssetsPlugin() {
                 }
                 // If the import path resolves to a file in `node_modules/`, we ignore that file:
                 //  - Direct CSS dependencies are included though, such as `import 'bootstrap/theme/dark.css'`. (Because the above if-branch for CSS files will add the file.)
-                //  - Loading CSS from a library (living in `node_modules/`) in a non-direct way is non-standard; we can safely not support this case. (I'm not aware of any library that does this.)
+                //  - Loading CSS from a library (living in `node_modules/`) in a non-direct way is unconventional; we can safely not support this case. (I'm not aware of any library that does this.)
                 assertPosixPath(file);
                 if (file.includes('/node_modules/')) {
                     return emptyModule(file, importer);

package/dist/esm/node/plugin/plugins/importUserCode/addImportStatement.d.ts

@@ -0,0 +1,14 @@
+export { addImportStatement };
+/**
+ * Naming:
+ *   `import { someExport as someImport } from './some-file'`
+ * <=>
+ *   `{`
+ *      `importPath: './some-file',`
+ *      `exportName: 'someExport',`
+ *      `importName: 'someImport',`
+ *    `}`
+ */
+declare function addImportStatement(importStatements: string[], importPath: string, exportName: string): {
+    importName: string;
+};

package/dist/esm/node/plugin/plugins/importUserCode/{generateEagerImport.js → addImportStatement.js}

@@ -1,5 +1,4 @@
-export { generateEagerImport };
-let varCounterGlobal = 0;
+export { addImportStatement };
 /**
  * Naming:
  *   `import { someExport as someImport } from './some-file'`
@@ -9,14 +8,12 @@ let varCounterGlobal = 0;
  *      `exportName: 'someExport',`
  *      `importName: 'someImport',`
  *    `}`
- * We discard the information that the import variable is called `someImport` because we don't need it.
  */
-function generateEagerImport(importPath, varCounter, exportName) {
-    if (varCounter === undefined)
-        varCounter = varCounterGlobal++;
-    const importName = `import_${varCounter}`;
+function addImportStatement(importStatements, importPath, exportName) {
+    const importCounter = importStatements.length + 1;
+    const importName = `import${importCounter}`;
     const importLiteral = (() => {
-        if (!exportName || exportName === '*') {
+        if (exportName === '*') {
             return `* as ${importName}`;
         }
         if (exportName === 'default') {
@@ -25,5 +22,6 @@ function generateEagerImport(importPath, varCounter, exportName) {
         return `{ ${exportName} as ${importName} }`;
     })();
     const importStatement = `import ${importLiteral} from '${importPath}';`;
-    return { importName, importStatement };
+    importStatements.push(importStatement);
+    return { importName };
 }

package/dist/esm/node/plugin/plugins/importUserCode/getVirtualFileImportUserCode.js

@@ -63,7 +63,6 @@ export const pageFilesExportNamesLazy = {};
 export const pageFilesExportNamesEager = {};
 export const pageFilesList = [];
 export const neverLoaded = {};
-export const isGeneratedFile = true;
 
 ${await getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRouting, config)}
 

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

@@ -56,7 +56,8 @@ type ConfigDefinitionInternal = Omit<ConfigDefinition, 'env'> & {
     _userEffectDefinedAtFilePath?: DefinedAtFilePath;
     env: ConfigEnvInternal;
 };
-type ConfigDefinitions = Record<string, ConfigDefinitionInternal>;
+type ConfigDefinitions = Record<string, // configName
+ConfigDefinitionInternal>;
 type ConfigDefinitionsBuiltIn = Record<ConfigNameBuiltIn, ConfigDefinitionInternal>;
 declare const configDefinitionsBuiltIn: ConfigDefinitionsBuiltIn;
 type ConfigNameGlobal = 'onPrerenderStart' | 'onBeforeRoute' | 'prerender' | 'disableAutoFullBuild' | 'includeAssetsImportedByServer' | 'baseAssets' | 'baseServer' | 'redirects' | 'trailingSlash' | 'disableUrlNormalization';

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

@@ -21,7 +21,7 @@ const configDefinitionsBuiltIn = {
         env: { server: true }
     },
     onBeforePrerenderStart: {
-        env: { server: true }
+        env: { server: true, production: true }
     },
     Page: {
         env: { server: true, client: true }
@@ -47,7 +47,7 @@ const configDefinitionsBuiltIn = {
     },
     client: {
         // The value of the client config is merely the file path to the client entry file, which is only needed on the sever-side
-        env: { server: true },
+        env: { server: true, config: true },
         _valueIsFilePath: true
     },
     clientRouting: {
@@ -95,7 +95,7 @@ const configDefinitionsBuiltIn = {
 };
 const configDefinitionsBuiltInGlobal = {
     onPrerenderStart: {
-        env: { server: true }
+        env: { server: true, production: true }
     },
     onBeforeRoute: {
         env: { server: true, client: 'if-client-routing', eager: true }