vike 0.4.144 → 0.4.145-commit-2520555

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

@@ -26,7 +26,7 @@ async function loadPageFiles(pageId) {
         _pageFilesAll: pageFilesAll,
         _pageConfigs: pageConfigs
     });
-    objectAssign(pageContextAddendum, await loadPageFilesClientSide(pageFilesAll, pageConfigs, pageId));
+    objectAssign(pageContextAddendum, await loadPageFilesClientSide(pageId, pageContextAddendum));
     pageFilesAll
         .filter((p) => p.fileType !== '.page.server')
         .forEach((p) => {

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

@@ -19,10 +19,11 @@ async function executeOnRenderClientHook(pageContext, isClientRouting) {
         }
     }
     if (!hook) {
-        const urlLogical = getUrlLogical(pageContext);
+        const urlToShowToUser = getUrlToShowToUser(pageContext);
+        assert(urlToShowToUser);
         if (pageContext._pageConfigs.length > 0) {
             // V1 design
-            assertUsage(false, `No onRenderClient() hook defined for URL '${urlLogical}', but it's needed, see https://vike.dev/onRenderClient`);
+            assertUsage(false, `No onRenderClient() hook defined for URL '${urlToShowToUser}', but it's needed, see https://vike.dev/onRenderClient`);
         }
         else {
             // TODO/v1-release: remove
@@ -30,11 +31,11 @@ async function executeOnRenderClientHook(pageContext, isClientRouting) {
             const pageClientsFilesLoaded = pageContext._pageFilesLoaded.filter((p) => p.fileType === '.page.client');
             let errMsg;
             if (pageClientsFilesLoaded.length === 0) {
-                errMsg = 'No file `*.page.client.*` found for URL ' + urlLogical;
+                errMsg = 'No file `*.page.client.*` found for URL ' + urlToShowToUser;
             }
             else {
                 errMsg =
-                    'One of the following files should export a `render()` hook: ' +
+                    'One of the following files should export a render() hook: ' +
                         pageClientsFilesLoaded.map((p) => p.filePath).join(' ');
             }
             assertUsage(false, errMsg);
@@ -47,7 +48,7 @@ async function executeOnRenderClientHook(pageContext, isClientRouting) {
     const hookResult = await executeHook(() => renderHook(pageContextForUserConsumption), hookName, hook.hookFilePath);
     assertUsage(hookResult === undefined, `The ${hookName}() hook defined by ${hook.hookFilePath} isn't allowed to return a value`);
 }
-function getUrlLogical(pageContext) {
+function getUrlToShowToUser(pageContext) {
     let url;
     // try/catch to avoid passToClient assertUsage() (although: this may not be needed anymore, since we're now accessing pageContext and not pageContextForUserConsumption)
     try {

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

@@ -14,14 +14,14 @@ function getPageContextProxyForUser(pageContext) {
             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.`);
-            assertPassToClient(pageContext, prop, `pageContext[${propName}] isn't available on the client-side because ${propName} is missing in passToClient, see https://vike.dev/passToClient`);
+            assertIsDefined(pageContext, prop);
             return val;
         }
     });
 }
-function assertPassToClient(pageContext, prop, errMsg) {
-    // We disable assertPassToClient() 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 `assertPassToClient()` failure if e.g. `pageContextOldReactive.routeParams = pageContextNew.routeParams` and `pageContextOldReactive` has no `routeParams`.
+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')
         return;
@@ -30,17 +30,23 @@ function assertPassToClient(pageContext, prop, errMsg) {
         return;
     if (isExpected(prop))
         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._hasPageContextFromServer && !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, errMsg);
+        assertUsage(false, `pageContext[${propName}] isn't available on the client-side because ${propName} is missing in passToClient, see https://vike.dev/passToClient`);
     }
     else {
-        // Do nothing, not even a warning.
-        // Because we don't know whether the user expects the pageContext value to be undefined. (E.g. a client-side onBeforeRender() hook conditionally setting a pageContext value.)
+        // 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.)
     }
 }
 const IGNORE_LIST = [

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

@@ -1,8 +1,13 @@
-import { type PageFile, type PageContextExports } from '../../shared/getPageFiles.js';
-import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
 export { loadPageFilesClientSide };
 export { isErrorFetchingStaticAssets };
-declare function loadPageFilesClientSide(pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[], pageId: string): Promise<PageContextExports & {
+export type { PageContextPageFiles };
+import { type PageFile, type PageContextExports } from '../../shared/getPageFiles.js';
+import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
+type PageContextPageFiles = {
+    _pageFilesAll: PageFile[];
+    _pageConfigs: PageConfigRuntime[];
+};
+declare function loadPageFilesClientSide(pageId: string, pageContext: PageContextPageFiles): Promise<PageContextExports & {
     _pageFilesLoaded: PageFile[];
 }>;
 declare function isErrorFetchingStaticAssets(err: unknown): boolean;

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

@@ -1,12 +1,12 @@
+export { loadPageFilesClientSide };
+export { isErrorFetchingStaticAssets };
 import { getPageFilesClientSide, getExports } from '../../shared/getPageFiles.js';
 import { findPageConfig } from '../../shared/page-configs/findPageConfig.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
-export { loadPageFilesClientSide };
-export { isErrorFetchingStaticAssets };
 const stamp = '__whileFetchingAssets';
-async function loadPageFilesClientSide(pageFilesAll, pageConfigs, pageId) {
-    const pageFilesClientSide = getPageFilesClientSide(pageFilesAll, pageId);
-    const pageConfig = findPageConfig(pageConfigs, pageId);
+async function loadPageFilesClientSide(pageId, pageContext) {
+    const pageFilesClientSide = getPageFilesClientSide(pageContext._pageFilesAll, pageId);
+    const pageConfig = findPageConfig(pageContext._pageConfigs, pageId);
     let pageConfigLoaded;
     // @ts-ignore Since dist/cjs/client/ is never used, we can ignore this error.
     const isDev = import.meta.env.DEV;

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

@@ -1,10 +1,10 @@
 export { buildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
-import { assert, resolveOutDir, isObject, viteIsSSR, getFilePathAbsolute, addOnBeforeLogHook, removeFileExtention, unique, assertPosixPath, assertUsage, getOutDirs, } from '../utils.js';
+import { assert, resolveOutDir, isObject, viteIsSSR, getFilePathAbsolute, addOnBeforeLogHook, removeFileExtention, unique, assertPosixPath, assertUsage } from '../utils.js';
 import { virtualFileIdImportUserCodeServer } from '../../shared/virtual-files/virtualFileImportUserCode.js';
 import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
-import { getConfigValue } from '../../../shared/page-configs/utils.js';
+import { getConfigValue } from '../../../shared/page-configs/helpers.js';
 import { findPageFiles } from '../shared/findPageFiles.js';
 import { getConfigVike } from '../../shared/getConfigVike.js';
 import { getVirtualFileIdPageConfigValuesAll } from '../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
@@ -69,7 +69,7 @@ function buildConfig() {
 async function getEntries(config) {
     const configVike = await getConfigVike(config);
     const pageFileEntries = await getPageFileEntries(config, configVike.includeAssetsImportedByServer); // TODO/v1-release: remove
-    const { pageConfigs } = await getVikeConfig(config.root, getOutDirs(config).outDirRoot, false, configVike.extensions);
+    const { pageConfigs } = await getVikeConfig(config, false);
     assertUsage(Object.keys(pageFileEntries).length !== 0 || pageConfigs.length !== 0, 'At least one page should be defined, see https://vike.dev/add');
     if (viteIsSSR(config)) {
         const serverEntries = analyzeServerEntries(pageConfigs);

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

@@ -13,9 +13,6 @@ function commonConfig() {
     return [
         {
             name: 'vike-commonConfig-1',
-            config: () => ({
-                appType: 'custom'
-            }),
             configResolved(config) {
                 installRequireShim_setUserRootDir(config.root);
             }

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

@@ -1,6 +1,6 @@
 export { resolveVikeConfig };
 import { assertVikeConfig } from './assertVikeConfig.js';
-import { getOutDirs, isDev2 } from '../../utils.js';
+import { isDev2 } from '../../utils.js';
 import { findConfigVikeFromStemPackages } from './findConfigVikeFromStemPackages.js';
 import { pickFirst } from './pickFirst.js';
 import { resolveExtensions } from './resolveExtensions.js';
@@ -12,19 +12,19 @@ function resolveVikeConfig(vikeConfig) {
         name: 'vike:resolveVikeConfig',
         enforce: 'pre',
         async configResolved(config) {
-            const promise = resolveConfig(vikeConfig, config);
+            const promise = getConfigVikPromise(vikeConfig, config);
             config.configVikePromise = promise;
             await promise;
         }
     };
 }
-async function resolveConfig(vikeConfig, config) {
+async function getConfigVikPromise(vikeConfig, config) {
     const fromPluginOptions = (vikeConfig ?? {});
     const fromViteConfig = (config.vike ?? {});
     const fromStemPackages = await findConfigVikeFromStemPackages(config.root);
     const configs = [fromPluginOptions, ...fromStemPackages, fromViteConfig];
     const extensions = resolveExtensions(configs, config);
-    const { globalVikeConfig: fromPlusConfigFile } = await getVikeConfig(config.root, getOutDirs(config).outDirRoot, isDev2(config), extensions);
+    const { globalVikeConfig: fromPlusConfigFile } = await getVikeConfig(config, isDev2(config), false, extensions);
     configs.push(fromPlusConfigFile);
     assertVikeConfig(fromPlusConfigFile, ({ prop, errMsg }) => {
         // TODO: add config file path ?

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

@@ -1,12 +1,12 @@
 export { determineOptimizeDeps };
 import { findPageFiles } from '../../shared/findPageFiles.js';
-import { assert, getFilePathAbsolute, getOutDirs, isNotNullish, isNpmPackageImport, unique } from '../../utils.js';
+import { assert, getFilePathAbsolute, isNotNullish, isNpmPackageImport, unique } from '../../utils.js';
 import { getVikeConfig } from '../importUserCode/v1-design/getVikeConfig.js';
 import { getConfigValueSourcesRelevant } from '../../shared/getConfigValueSourcesRelevant.js';
 import { analyzeClientEntries } from '../buildConfig.js';
 import { virtualFileIdImportUserCodeClientCR, virtualFileIdImportUserCodeClientSR } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
 async function determineOptimizeDeps(config, configVike, isDev) {
-    const { pageConfigs } = await getVikeConfig(config.root, getOutDirs(config).outDirRoot, isDev, configVike.extensions);
+    const { pageConfigs } = await getVikeConfig(config, isDev);
     const { entries, include } = await getPageDeps(config, pageConfigs, isDev);
     {
         // This actually doesn't work: Vite's dep optimizer doesn't seem to be able to crawl virtual files.
@@ -34,18 +34,18 @@ async function getPageDeps(config, pageConfigs, isDev) {
             configValueSourcesRelevant.forEach((configValueSource) => {
                 if (!configValueSource.valueIsImportedAtRuntime)
                     return;
-                const { definedAtInfo, configEnv } = configValueSource;
+                const { definedAt, configEnv } = configValueSource;
                 if (configEnv !== 'client-only' && configEnv !== 'server-and-client')
                     return;
-                if (definedAtInfo.filePathRelativeToUserRootDir !== null) {
-                    const { filePathAbsolute } = definedAtInfo;
-                    assert(filePathAbsolute);
+                if (definedAt.filePathRelativeToUserRootDir !== null) {
+                    const { filePathAbsoluteFilesystem } = definedAt;
+                    assert(filePathAbsoluteFilesystem);
                     // Surprisingly Vite expects entries to be absolute paths
-                    entries.push(filePathAbsolute);
+                    entries.push(filePathAbsoluteFilesystem);
                 }
                 else {
-                    // Adding definedAtInfo.filePathAbsolute doesn't work for npm packages, I guess because of Vite's config.server.fs.allow
-                    const { importPathAbsolute } = definedAtInfo;
+                    // Adding definedAt.filePathAbsoluteFilesystem doesn't work for npm packages, I guess because of Vite's config.server.fs.allow
+                    const { importPathAbsolute } = definedAt;
                     assert(importPathAbsolute);
                     // We need to differentiate between npm package imports and path aliases.
                     // There are path aliases that cannot be distinguished from npm package names.

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

@@ -21,6 +21,7 @@ function devConfig() {
             apply,
             config() {
                 return {
+                    appType: 'custom',
                     optimizeDeps: {
                         exclude: [
                             // We exclude the vike client to be able to use `import.meta.glob()`

package/dist/esm/node/plugin/plugins/envVars.d.ts

@@ -1,3 +1,5 @@
 export { envVarsPlugin };
+export { applyEnvVar };
 import type { Plugin } from 'vite';
 declare function envVarsPlugin(): Plugin;
+declare function applyEnvVar(envName: string, envVal: string, code: string): string;

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

@@ -1,6 +1,8 @@
 export { envVarsPlugin };
+// For ./envVars.spec.ts
+export { applyEnvVar };
 import { loadEnv } from 'vite';
-import { assert, assertPosixPath, assertUsage, assertWarning, getFilePathRelativeToUserRootDir, lowerFirst } from '../utils.js';
+import { assert, assertPosixPath, assertUsage, assertWarning, escapeRegex, getFilePathRelativeToUserRootDir, lowerFirst } from '../utils.js';
 function envVarsPlugin() {
     let envsAll;
     let config;
@@ -33,33 +35,46 @@ function envVarsPlugin() {
                         : [config.envPrefix];
                 return !envPrefix.some((prefix) => key.startsWith(prefix));
             })
-                .forEach(([key, val]) => {
-                const varName = `import.meta.env.${key}`;
-                const publicPrefix = 'PUBLIC_ENV__';
-                const keyPublic = `${publicPrefix}${key}`;
-                const isPrivate = !key.startsWith(publicPrefix);
-                if (isPrivate && isClientSide) {
-                    if (!code.includes(varName))
-                        return;
-                    const filePathToShowToUser = getFilePathRelativeToUserRootDir(id, config.root);
-                    const errMsgAddendum = isBuild ? '' : ' (vike will prevent your app from building for production)';
-                    const errMsg = `${varName} used in ${filePathToShowToUser} and therefore included in client-side bundle which can be be a security leak${errMsgAddendum}, remove ${varName} or rename ${key} to ${keyPublic}, see https://vike.dev/env`;
-                    if (isBuild) {
-                        assertUsage(false, errMsg);
-                    }
-                    else {
-                        // Only a warning for faster development DX (e.g. when use toggles `ssr: boolean` or `onBeforeRenderIsomorph: boolean`)
-                        assertWarning(false, errMsg, { onlyOnce: true });
+                .forEach(([envName, envVal]) => {
+                // Security check
+                {
+                    const envStatement = getEnvStatement(envName);
+                    const publicPrefix = 'PUBLIC_ENV__';
+                    const isPrivate = !envName.startsWith(publicPrefix);
+                    if (isPrivate && isClientSide) {
+                        if (!code.includes(envStatement))
+                            return;
+                        const filePathToShowToUser = getFilePathRelativeToUserRootDir(id, config.root);
+                        const errMsgAddendum = isBuild ? '' : ' (Vike will prevent your app from building for production)';
+                        const keyPublic = `${publicPrefix}${envName}`;
+                        const errMsg = `${envStatement} is used in client-side file ${filePathToShowToUser} which means that the environment variable ${envName} will be included in client-side bundles and, therefore, ${envName} will be publicly exposed which can be a security leak${errMsgAddendum}. Use ${envStatement} only in server-side files, or rename ${envName} to ${keyPublic}, see https://vike.dev/env`;
+                        if (isBuild) {
+                            assertUsage(false, errMsg);
+                        }
+                        else {
+                            // Only a warning for faster development DX (e.g. when user toggles `ssr: boolean` or `onBeforeRenderIsomorph: boolean`)
+                            assertWarning(false, errMsg, { onlyOnce: true });
+                        }
                     }
+                    // Double check
+                    assert(!(isPrivate && isClientSide) || !isBuild);
                 }
-                assert(!(isPrivate && isClientSide) || !isBuild);
-                code = code.replaceAll(varName, JSON.stringify(val));
+                // Apply
+                code = applyEnvVar(envName, envVal, code);
             });
             // No need for low-resolution source map since line numbers didn't change. (Does Vite do high-resolution column numbers source mapping?)
             return code;
         }
     };
 }
+function applyEnvVar(envName, envVal, code) {
+    const envStatement = getEnvStatement(envName);
+    const regex = new RegExp(escapeRegex(envStatement) + '\\b', 'g');
+    return code.replace(regex, JSON.stringify(envVal));
+}
+function getEnvStatement(envName) {
+    return `import.meta.env.${envName}`;
+}
 function getIsClientSide(config, options) {
     const isBuild = config.command === 'build';
     if (isBuild) {

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

@@ -26,15 +26,15 @@ function importBuild() {
     ];
 }
 function getImporterCode(config, pageFilesEntry) {
-    const importPathAbsolute = toPosixPath(
+    const filePathAbsolute = toPosixPath(
     // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/plugin/plugins/importBuild/index.js
     require_.resolve(`../../../../../../dist/esm/node/runtime/globalContext/loadImportBuild.js`));
     const { outDirServer } = getOutDirs(config);
-    const importPath = path.posix.relative(outDirServer, importPathAbsolute);
+    const filePathRelative = path.posix.relative(outDirServer, filePathAbsolute);
     // The only reason we went for using CJS require() instead of ESM import() is because import() doesn't support .json files
     const importerCode = [
         '(async () => {',
-        `  const { setImportBuildGetters } = await import('${importPath}');`,
+        `  const { setImportBuildGetters } = await import('${filePathRelative}');`,
         '  setImportBuildGetters({',
         `    pageFiles: () => import('./${pageFilesEntry}'),`,
         "    clientManifest: () => require('../assets.json'),",

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

@@ -140,7 +140,7 @@ export const pageFilesList = [];
 export const neverLoaded = {};
 export const isGeneratedFile = true;
 
-${await getVirtualFilePageConfigs(config.root, getOutDirs(config).outDirRoot, isForClientSide, isDev, id, configVike, isClientRouting)}
+${await getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRouting, config)}
 
 `;
     fileTypes

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

@@ -47,7 +47,7 @@ function importUserCode() {
                 return undefined;
             id = getVirtualFileId(id);
             if (isVirtualFileIdPageConfigValuesAll(id)) {
-                const code = await getVirtualFilePageConfigValuesAll(id, config.root, getOutDirs(config).outDirRoot, isDev, configVike);
+                const code = await getVirtualFilePageConfigValuesAll(id, isDev, config);
                 return code;
             }
             if (isVirtualFileIdImportUserCode(id)) {
@@ -111,8 +111,8 @@ function handleHotUpdate(ctx, config, configVike) {
         return virtualModules;
     }
 }
-function isVikeConfigModule(filePathAbsolute) {
-    return vikeConfigDependencies.has(filePathAbsolute);
+function isVikeConfigModule(filePathAbsoluteFilesystem) {
+    return vikeConfigDependencies.has(filePathAbsoluteFilesystem);
 }
 function reloadConfig(filePath, config, configVike, op) {
     {

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

@@ -4,7 +4,7 @@ export type { ConfigDefinition };
 export type { ConfigDefinitionInternal };
 export type { ConfigNameGlobal };
 export type { ConfigEffect };
-import type { ConfigEnvInternal, ConfigEnv, ConfigValueSources } from '../../../../../../shared/page-configs/PageConfig.js';
+import type { ConfigEnvInternal, ConfigEnv, ConfigValueSources, DefinedAtFileFullInfo } from '../../../../../../shared/page-configs/PageConfig.js';
 import type { Config, ConfigNameBuiltIn } from '../../../../../../shared/page-configs/Config.js';
 /** The meta definition of a config.
  *
@@ -46,6 +46,7 @@ type ConfigEffect = (config: {
 type ConfigDefinitionInternal = Omit<ConfigDefinition, 'env'> & {
     _computed?: (configValueSources: ConfigValueSources) => unknown;
     _valueIsFilePath?: true;
+    _userEffectDefinedAt?: DefinedAtFileFullInfo;
     env: ConfigEnvInternal;
 };
 type ConfigDefinitionsBuiltIn = Record<ConfigNameBuiltIn, ConfigDefinitionInternal>;

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

@@ -48,16 +48,17 @@ const configDefinitionsBuiltIn = {
         _valueIsFilePath: true
     },
     clientRouting: {
-        env: 'server-and-client' // TODO: config-only instead?
+        // We could make it 'server-only' (we don't yet because of some legacy V0.4 design code)
+        env: 'server-and-client'
     },
     prerender: {
-        env: 'server-only'
+        env: 'config-only'
     },
     hydrationCanBeAborted: {
-        env: 'client-only' // TODO: config-only instead?
+        env: 'client-only'
     },
     prefetchStaticAssets: {
-        env: 'client-only' // TODO: config-only instead?
+        env: 'client-only'
     },
     extends: {
         env: 'config-only'

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

@@ -11,7 +11,7 @@ export { getLogicalPath };
  * getLocationId('/pages/some-page') => '/pages/some-page'
  * getLocationId('/renderer/+config.js') => '/renderer'
  */
-declare function getLocationId(somePath: string): string;
+declare function getLocationId(filePathAbsoluteVite: string): string;
 /** Get URL determined by filesystem path */
 declare function getFilesystemRouteString(locationId: string): string;
 /**

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

@@ -13,8 +13,8 @@ import { assert, assertPosixPath, getNpmPackageImportPath, isNpmPackageImport, h
  * getLocationId('/pages/some-page') => '/pages/some-page'
  * getLocationId('/renderer/+config.js') => '/renderer'
  */
-function getLocationId(somePath) {
-    const locationId = removeFilename(somePath, true);
+function getLocationId(filePathAbsoluteVite) {
+    const locationId = removeFilename(filePathAbsoluteVite, true);
     assertLocationId(locationId);
     return locationId;
 }
@@ -110,21 +110,21 @@ function removeDirectories(somePath, removeDirs) {
         somePath = '/';
     return somePath;
 }
-function removeFilename(filePath, optional) {
-    assertPosixPath(filePath);
-    assert(filePath.startsWith('/') || isNpmPackageImport(filePath));
+function removeFilename(filePathAbsoluteVite, optional) {
+    assertPosixPath(filePathAbsoluteVite);
+    assert(filePathAbsoluteVite.startsWith('/') || isNpmPackageImport(filePathAbsoluteVite));
     {
-        const filename = filePath.split('/').slice(-1)[0];
+        const filename = filePathAbsoluteVite.split('/').slice(-1)[0];
         if (!filename.includes('.')) {
             assert(optional);
-            return filePath;
+            return filePathAbsoluteVite;
         }
     }
-    filePath = filePath.split('/').slice(0, -1).join('/');
-    if (filePath === '')
-        filePath = '/';
-    assertLocationId(filePath);
-    return filePath;
+    let locationId = filePathAbsoluteVite.split('/').slice(0, -1).join('/');
+    if (locationId === '')
+        locationId = '/';
+    assertLocationId(locationId);
+    return locationId;
 }
 function getFilesystemRouteDefinedBy(locationId) {
     if (locationId === '/')

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

@@ -4,6 +4,7 @@ export { vikeConfigDependencies };
 export { isVikeConfigFile };
 import type { PageConfigGlobalBuildTime, PageConfigBuildTime } from '../../../../../shared/page-configs/PageConfig.js';
 import type { ExtensionResolved } from '../../../../../shared/ConfigVike.js';
+import type { ResolvedConfig } from 'vite';
 type VikeConfig = {
     pageConfigs: PageConfigBuildTime[];
     pageConfigGlobal: PageConfigGlobalBuildTime;
@@ -11,5 +12,5 @@ type VikeConfig = {
 };
 declare const vikeConfigDependencies: Set<string>;
 declare function reloadVikeConfig(userRootDir: string, outDirRoot: string, extensions: ExtensionResolved[]): void;
-declare function getVikeConfig(userRootDir: string, outDirRoot: string, isDev: boolean, extensions: ExtensionResolved[], tolerateInvalidConfig?: boolean): Promise<VikeConfig>;
+declare function getVikeConfig(config: ResolvedConfig, isDev: boolean, tolerateInvalidConfig?: boolean, extensions?: ExtensionResolved[]): Promise<VikeConfig>;
 declare function isVikeConfigFile(filePath: string): boolean;