vike 0.4.241 → 0.4.242-commit-4a9fae0

package/dist/esm/node/vite/plugins/build/handleAssetsManifest.d.ts

@@ -3,14 +3,12 @@ export { handleAssetsManifest_getBuildConfig };
 export { handleAssetsManifest_isFixEnabled };
 export { handleAssetsManifest_assertUsageCssCodeSplit };
 export { handleAssetsManifest_assertUsageCssTarget };
-export { handleAssetsManifest_workaroundCssTarget_part1 };
-export { handleAssetsManifest_workaroundCssTarget_part2 };
+export { handleAssetsManifest_alignCssTarget };
 import type { Environment, ResolvedConfig, Rollup } from 'vite';
 type Bundle = Rollup.OutputBundle;
 declare function handleAssetsManifest_isFixEnabled(): boolean;
 declare function handleAssetsManifest_assertUsageCssCodeSplit(config: ResolvedConfig): void;
-declare function handleAssetsManifest_workaroundCssTarget_part1(config: ResolvedConfig): void;
-declare function handleAssetsManifest_workaroundCssTarget_part2(): void;
+declare function handleAssetsManifest_alignCssTarget(config: ResolvedConfig): void;
 declare function handleAssetsManifest_assertUsageCssTarget(config: ResolvedConfig, env: Environment): void;
 declare function handleAssetsManifest_getBuildConfig(): Promise<{
     readonly ssrEmitAssets: true | undefined;

package/dist/esm/node/vite/plugins/build/handleAssetsManifest.js

@@ -3,8 +3,7 @@ export { handleAssetsManifest_getBuildConfig };
 export { handleAssetsManifest_isFixEnabled };
 export { handleAssetsManifest_assertUsageCssCodeSplit };
 export { handleAssetsManifest_assertUsageCssTarget };
-export { handleAssetsManifest_workaroundCssTarget_part1 };
-export { handleAssetsManifest_workaroundCssTarget_part2 };
+export { handleAssetsManifest_alignCssTarget };
 import fs from 'node:fs/promises';
 import fs_sync from 'node:fs';
 import path from 'node:path';
@@ -20,7 +19,6 @@ import { set_macro_ASSETS_MANIFEST } from './pluginProdBuildEntry.js';
 import { getManifestFilePathRelative } from '../../shared/getManifestFilePathRelative.js';
 const globalObject = getGlobalObject('handleAssetsManifest.ts', {
     assetsJsonFilePath: undefined,
-    cssTarget: '__VIKE__UNSET',
     targetsAll: [],
     configsAll: [],
 });
@@ -221,15 +219,13 @@ function handleAssetsManifest_assertUsageCssCodeSplit(config) {
         return;
     assertWarning(config.build.cssCodeSplit, `${pc.cyan('build.cssCodeSplit')} shouldn't be set to ${pc.cyan('false')} (https://github.com/vikejs/vike/issues/1993)`, { onlyOnce: true });
 }
-function handleAssetsManifest_workaroundCssTarget_part1(config) {
+function handleAssetsManifest_alignCssTarget(config) {
     globalObject.configsAll.push(config);
-    if (!isViteServerSide_viteEnvOptional(config, undefined)) {
-        globalObject.cssTarget = config.build.cssTarget;
-    }
-}
-function handleAssetsManifest_workaroundCssTarget_part2() {
-    assert(globalObject.cssTarget !== '__VIKE__UNSET');
-    globalObject.configsAll.forEach((c) => (c.build.cssTarget = globalObject.cssTarget));
+    const { cssTarget } = globalObject.configsAll
+        .filter((c) => !isViteServerSide_viteEnvOptional(c, undefined))
+        .at(-1).build;
+    assert(cssTarget);
+    globalObject.configsAll.forEach((c) => (c.build.cssTarget = cssTarget));
 }
 function handleAssetsManifest_assertUsageCssTarget(config, env) {
     if (!handleAssetsManifest_isFixEnabled())

package/dist/esm/node/vite/plugins/build/pluginBuildApp.js

@@ -3,7 +3,7 @@ import { runPrerender_forceExit } from '../../../prerender/runPrerenderEntry.js'
 import { resolveOutDir } from '../../shared/getOutDirs.js';
 import { assert, assertWarning, getGlobalObject, onSetupBuild } from '../../utils.js';
 import { isPrerenderAutoRunEnabled, wasPrerenderRun } from '../../../prerender/context.js';
-import { isViteCliCall, getViteConfigFromCli } from '../../shared/isViteCliCall.js';
+import { isViteCli, getViteConfigForBuildFromCli } from '../../shared/isViteCli.js';
 import pc from '@brillout/picocolors';
 import { logErrorHint } from '../../../runtime/renderPage/logErrorHint.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
@@ -113,9 +113,6 @@ function pluginBuildApp() {
                 handler() {
                     onSetupBuild();
                     handleAssetsManifest_assertUsageCssTarget(config, this.environment);
-                    /* Let vike:build:pluginBuildApp force exit
-                    runPrerender_forceExit()
-                    */
                 },
             },
         },
@@ -142,7 +139,7 @@ async function triggerPrerendering(config, viteEnv, bundle) {
 }
 async function abortViteBuildSsr() {
     const vikeConfig = await getVikeConfigInternal();
-    if (vikeConfig.config.disableAutoFullBuild !== true && isViteCliCall() && getViteConfigFromCli()?.build.ssr) {
+    if (vikeConfig.config.disableAutoFullBuild !== true && isViteCli() && getViteConfigForBuildFromCli()?.build.ssr) {
         assertWarning(false, `The CLI call ${pc.cyan('$ vite build --ssr')} is superfluous since ${pc.cyan('$ vite build')} also builds the server-side. If you want two separate build steps then use https://vike.dev/disableAutoFullBuild or use Vite's ${pc.cyan('build()')} API.`, { onlyOnce: true });
         process.exit(0);
     }
@@ -150,7 +147,7 @@ async function abortViteBuildSsr() {
 function isDisabled(vikeConfig) {
     const { disableAutoFullBuild } = vikeConfig.config;
     if (disableAutoFullBuild === undefined || disableAutoFullBuild === 'prerender') {
-        const isUserUsingViteApi = !isViteCliCall() && !isVikeCliOrApi();
+        const isUserUsingViteApi = !isViteCli() && !isVikeCliOrApi();
         return isUserUsingViteApi;
     }
     else {
@@ -161,9 +158,9 @@ function isPrerenderForceExit() {
     return globalObject.forceExit;
 }
 function getFullBuildInlineConfig(config) {
-    const configFromCli = !isViteCliCall() ? null : getViteConfigFromCli();
-    if (config._viteConfigFromUserEnhanced) {
-        return config._viteConfigFromUserEnhanced;
+    const configFromCli = !isViteCli() ? null : getViteConfigForBuildFromCli();
+    if (config._viteConfigFromUserResolved) {
+        return config._viteConfigFromUserResolved;
     }
     else {
         return {

package/dist/esm/node/vite/plugins/build/pluginBuildConfig.js

@@ -10,31 +10,18 @@ import { prependEntriesDir } from '../../../shared/prependEntriesDir.js';
 import { getFilePathResolved } from '../../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../../shared/page-configs/getConfigValueBuildTime.js';
 import { isViteServerSide_viteEnvOptional } from '../../shared/isViteServerSide.js';
-import { handleAssetsManifest_assertUsageCssCodeSplit, handleAssetsManifest_getBuildConfig, handleAssetsManifest_workaroundCssTarget_part1, handleAssetsManifest_workaroundCssTarget_part2, } from './handleAssetsManifest.js';
+import { handleAssetsManifest_assertUsageCssCodeSplit, handleAssetsManifest_getBuildConfig, handleAssetsManifest_alignCssTarget, } from './handleAssetsManifest.js';
 import { resolveIncludeAssetsImportedByServer } from '../../../runtime/renderPage/getPageAssets/retrievePageAssetsProd.js';
 function pluginBuildConfig() {
-    let config;
     return [
-        {
-            name: 'vike:build:pluginBuildConfig:post1',
-            apply: 'build',
-            enforce: 'post',
-            configResolved: {
-                order: 'post',
-                handler(config_) {
-                    config = config_;
-                    handleAssetsManifest_workaroundCssTarget_part1(config);
-                },
-            },
-        },
         {
             name: 'vike:build:pluginBuildConfig:post2',
             apply: 'build',
             enforce: 'post',
             configResolved: {
                 order: 'post',
-                async handler() {
-                    handleAssetsManifest_workaroundCssTarget_part2();
+                async handler(config) {
+                    handleAssetsManifest_alignCssTarget(config);
                     onSetupBuild();
                     assertRollupInput(config);
                     const entries = await getEntries(config);

package/dist/esm/node/vite/plugins/pluginCommon.d.ts

@@ -7,7 +7,7 @@ declare module 'vite' {
         _isDev?: boolean;
         _rootResolvedEarly?: string;
         _baseViteOriginal?: string;
-        _viteConfigFromUserEnhanced?: InlineConfig;
+        _viteConfigFromUserResolved?: InlineConfig;
     }
 }
 declare global {

package/dist/esm/node/vite/plugins/pluginCommon.js

@@ -1,13 +1,13 @@
 export { pluginCommon };
-import { assert, assertUsage, assertWarning, hasProp, isDevCheck, isDocker, isObject, isVitest } from '../utils.js';
+import { assert, assertUsage, assertWarning, hasProp, isDevCheck, isDocker, isExactlyOneTruthy, isObject, isVitest, } from '../utils.js';
 import { assertRollupInput } from './build/pluginBuildConfig.js';
 import { installRequireShim_setUserRootDir } from '@brillout/require-shim';
 import pc from '@brillout/picocolors';
 import { assertResolveAlias } from './pluginCommon/assertResolveAlias.js';
-import { isViteCliCall } from '../shared/isViteCliCall.js';
+import { isViteCli } from '../shared/isViteCli.js';
 import { isVikeCliOrApi } from '../../api/context.js';
 import { getVikeConfigInternal, setVikeConfigContext } from '../shared/resolveVikeConfigInternal.js';
-import { assertViteRoot, getViteRoot, normalizeViteRoot } from '../../api/prepareViteApiCall.js';
+import { assertViteRoot, getViteRoot, normalizeViteRoot } from '../../api/resolveViteConfigFromUser.js';
 import { temp_disablePrerenderAutoRun } from '../../prerender/context.js';
 const pluginName = 'vike:pluginCommon';
 globalThis.__VIKE__IS_PROCESS_SHARED_WITH_VITE = true;
@@ -20,12 +20,14 @@ function pluginCommon(vikeVitePluginOptions) {
                 order: 'pre',
                 async handler(configFromUser, env) {
                     const isDev = isDevCheck(env);
-                    const operation = env.command === 'build' ? 'build' : env.isPreview ? 'preview' : 'dev';
+                    const isBuild = env.command === 'build';
+                    const isPreview = env.isPreview;
+                    assert(isExactlyOneTruthy(isDev, isBuild, isPreview));
+                    const viteContext = isBuild ? 'build' : isPreview ? 'preview' : 'dev';
                     const rootResolvedEarly = configFromUser.root
                         ? normalizeViteRoot(configFromUser.root)
-                        : await getViteRoot(operation);
+                        : await getViteRoot(viteContext);
                     assert(rootResolvedEarly);
-                    // TO-DO/next-major-release: we can remove setVikeConfigContext() call here since with Vike's CLI it's already called at vike/node/api/prepareViteApiCall.ts
                     setVikeConfigContext({ userRootDir: rootResolvedEarly, isDev, vikeVitePluginOptions });
                     const vikeConfig = await getVikeConfigInternal();
                     return {
@@ -132,7 +134,7 @@ function assertSingleInstance(config) {
 function assertVikeCliOrApi(config) {
     if (isVikeCliOrApi())
         return;
-    if (isViteCliCall()) {
+    if (isViteCli()) {
         assert(!isVitest());
         return;
     }

package/dist/esm/node/vite/plugins/pluginReplaceConstantsGlobalThis.d.ts

@@ -1,4 +1,5 @@
 export { pluginReplaceConstantsGlobalThis };
+export type _LoadDeclareGlobal__VIKE__IS = never;
 import type { Plugin } from 'vite';
 declare global {
     /** Like `import.meta.env.DEV` but works for `node_modules/` packages with `ssr.external` */

package/dist/esm/node/vite/plugins/pluginViteConfigVikeExtensions.d.ts

@@ -0,0 +1,3 @@
+export { pluginViteConfigVikeExtensions };
+import type { Plugin } from 'vite';
+declare function pluginViteConfigVikeExtensions(): Promise<Plugin[]>;

package/dist/esm/node/vite/plugins/pluginViteConfigVikeExtensions.js

@@ -0,0 +1,32 @@
+export { pluginViteConfigVikeExtensions };
+import { mergeConfig } from 'vite';
+import { assertUsage, isObject } from '../utils.js';
+import { getVikeConfigInternalEarly } from '../../api/resolveViteConfigFromUser.js';
+// Apply +vite
+// - For example, Vike extensions adding Vite plugins
+async function pluginViteConfigVikeExtensions() {
+    const vikeConfig = await getVikeConfigInternalEarly();
+    if (vikeConfig === null)
+        return [];
+    let viteConfigFromExtensions = {};
+    const viteConfigsExtensions = vikeConfig._from.configsCumulative.vite;
+    if (!viteConfigsExtensions)
+        return [];
+    viteConfigsExtensions.values.forEach((v) => {
+        assertUsage(isObject(v.value), `${v.definedAt} should be an object`);
+        viteConfigFromExtensions = mergeConfig(viteConfigFromExtensions, v.value);
+    });
+    const pluginsFromExtensions = (viteConfigFromExtensions.plugins ?? []);
+    delete viteConfigFromExtensions.plugins;
+    return [
+        ...pluginsFromExtensions,
+        {
+            name: 'vike:pluginViteConfigVikeExtensions',
+            config: {
+                handler(_config) {
+                    return viteConfigFromExtensions;
+                },
+            },
+        },
+    ];
+}

package/dist/esm/node/vite/shared/isViteCli.d.ts

@@ -0,0 +1,13 @@
+export { isViteCli };
+export { getViteConfigForBuildFromCli };
+export { getViteCommandFromCli };
+declare function isViteCli(): boolean;
+type ConfigFromCli = {
+    root: undefined | string;
+    configFile: undefined | string;
+} & Record<string, unknown> & {
+    build: Record<string, unknown>;
+};
+type ViteCommand = 'dev' | 'build' | 'optimize' | 'preview';
+declare function getViteCommandFromCli(): ViteCommand | null;
+declare function getViteConfigForBuildFromCli(): null | ConfigFromCli;

package/dist/esm/node/vite/shared/isViteCli.js

@@ -0,0 +1,143 @@
+export { isViteCli };
+export { getViteConfigForBuildFromCli };
+export { getViteCommandFromCli };
+import { assert, isObject, toPosixPath } from '../utils.js';
+import { cac } from 'cac';
+const desc = 'vike:vite-cli-simulation';
+function isViteCli() {
+    let execPath = process.argv[1];
+    assert(execPath);
+    execPath = toPosixPath(execPath);
+    return (
+    // pnpm
+    execPath.endsWith('/bin/vite.js') ||
+        // npm & yarn
+        execPath.endsWith('/.bin/vite') ||
+        // Global install
+        execPath.endsWith('/bin/vite'));
+}
+function getViteCommandFromCli() {
+    if (!isViteCli())
+        return null;
+    let command;
+    const setCommand = (cmd) => {
+        assert(command === undefined);
+        command = cmd;
+    };
+    // Copied & adapted from Vite
+    // https://github.com/vitejs/vite/blob/d3e7eeefa91e1992f47694d16fe4dbe708c4d80e/packages/vite/src/node/cli.ts#L186-L188
+    const cli = cac(desc);
+    // dev
+    cli
+        .command('[root]', desc)
+        .alias('serve')
+        .alias('dev')
+        .action(() => {
+        setCommand('dev');
+    });
+    // build
+    cli.command('build [root]', desc).action(() => {
+        setCommand('build');
+    });
+    // optimize
+    cli.command('optimize [root]', desc).action(() => {
+        setCommand('optimize');
+    });
+    // preview
+    cli.command('preview [root]', desc).action(() => {
+        setCommand('preview');
+    });
+    cli.parse();
+    assert(command);
+    return command;
+}
+function getViteConfigForBuildFromCli() {
+    if (!isViteCli())
+        return null;
+    // Copied & adapted from Vite
+    const cli = cac(desc);
+    // Common configs
+    // https://github.com/vitejs/vite/blob/d3e7eeefa91e1992f47694d16fe4dbe708c4d80e/packages/vite/src/node/cli.ts#L169-L182
+    cli
+        .option('-c, --config <file>', desc)
+        .option('--base <path>', desc)
+        .option('-l, --logLevel <level>', desc)
+        .option('--clearScreen', desc)
+        .option('--configLoader <loader>', desc)
+        .option('-d, --debug [feat]', desc)
+        .option('-f, --filter <filter>', desc)
+        .option('-m, --mode <mode>', desc);
+    // Build configs
+    // https://github.com/vitejs/vite/blob/d3e7eeefa91e1992f47694d16fe4dbe708c4d80e/packages/vite/src/node/cli.ts#L286-L322
+    cli
+        .command('build [root]', desc)
+        .option('--target <target>', desc)
+        .option('--outDir <dir>', desc)
+        .option('--assetsDir <dir>', desc)
+        .option('--assetsInlineLimit <number>', desc)
+        .option('--ssr [entry]', desc)
+        .option('--sourcemap', desc)
+        .option('--minify [minifier]', desc)
+        .option('--manifest [name]', desc)
+        .option('--ssrManifest [name]', desc)
+        .option('--emptyOutDir', desc)
+        .option('-w, --watch', desc)
+        .option('--app', desc)
+        .action((root, options) => {
+        assert(isObject(options));
+        assert(root === undefined || typeof root === 'string');
+        assert(options.config === undefined || typeof options.config === 'string');
+        // https://github.com/vitejs/vite/blob/d3e7eeefa91e1992f47694d16fe4dbe708c4d80e/packages/vite/src/node/cli.ts#L331-L346
+        const buildOptions = cleanGlobalCLIOptions(cleanBuilderCLIOptions(options));
+        configFromCli = {
+            root,
+            base: options.base,
+            mode: options.mode,
+            configFile: options.config,
+            configLoader: options.configLoader,
+            logLevel: options.logLevel,
+            clearScreen: options.clearScreen,
+            build: buildOptions,
+            ...(options.app ? { builder: {} } : {}),
+        };
+    });
+    let configFromCli = null;
+    cli.parse();
+    return configFromCli;
+    // https://github.com/vitejs/vite/blob/d3e7eeefa91e1992f47694d16fe4dbe708c4d80e/packages/vite/src/node/cli.ts#L99
+    function cleanGlobalCLIOptions(options) {
+        const ret = { ...options };
+        delete ret['--'];
+        delete ret.c;
+        delete ret.config;
+        delete ret.base;
+        delete ret.l;
+        delete ret.logLevel;
+        delete ret.clearScreen;
+        delete ret.configLoader;
+        delete ret.d;
+        delete ret.debug;
+        delete ret.f;
+        delete ret.filter;
+        delete ret.m;
+        delete ret.mode;
+        delete ret.force;
+        delete ret.w;
+        // convert the sourcemap option to a boolean if necessary
+        if ('sourcemap' in ret) {
+            const sourcemap = ret.sourcemap;
+            ret.sourcemap = sourcemap === 'true' ? true : sourcemap === 'false' ? false : ret.sourcemap;
+        }
+        if ('watch' in ret) {
+            const watch = ret.watch;
+            ret.watch = watch ? {} : undefined;
+        }
+        return ret;
+    }
+    // https://github.com/vitejs/vite/blob/d3e7eeefa91e1992f47694d16fe4dbe708c4d80e/packages/vite/src/node/cli.ts#L141
+    function cleanBuilderCLIOptions(options) {
+        const ret = { ...options };
+        delete ret.app;
+        return ret;
+    }
+}

package/dist/esm/node/vite/shared/resolveVikeConfigInternal/transpileAndExecuteFile.js

@@ -141,6 +141,15 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                         return resolved;
                     }
                     assert(resolved.path);
+                    // Built-in modules e.g. node:fs
+                    if (resolved.path === args.path) {
+                        const isPointerImport = false;
+                        pointerImports[args.path] = isPointerImport;
+                        if (debug.isActivated)
+                            debug('onResolve() [built-in module]', { args, resolved });
+                        assert(resolved.external);
+                        return resolved;
+                    }
                     const importPathResolved = toPosixPath(resolved.path);
                     const importPathOriginal = args.path;
                     // Esbuild resolves path aliases.
@@ -185,7 +194,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                         // User-land config code (i.e. not runtime code) => let esbuild transpile it
                         assert(!isPointerImport && !isNpmPkgImport);
                         if (debug.isActivated)
-                            debug('onResolved()', { args, resolved, isPointerImport, isExternal });
+                            debug('onResolve() [non-external]', { args, resolved, isPointerImport, isExternal });
                         return resolved;
                     }
                     let importPathTranspiled;
@@ -217,7 +226,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                         }
                     }
                     if (debug.isActivated)
-                        debug('onResolved()', { args, resolved, importPathTranspiled, isPointerImport, isExternal });
+                        debug('onResolve() [external]', { args, resolved, importPathTranspiled, isPointerImport, isExternal });
                     assert(isExternal);
                     assert(
                     // Import of runtime code => handled by Vike

package/dist/esm/node/vite/shared/resolveVikeConfigInternal.d.ts

@@ -4,6 +4,7 @@ export { getVikeConfigInternal };
 export { getVikeConfigInternalOptional };
 export { getVikeConfigInternalSync };
 export { setVikeConfigContext };
+export { isVikeConfigContextSet };
 export { reloadVikeConfig };
 export { isV1Design };
 export { getConfVal };
@@ -45,6 +46,7 @@ declare function getVikeConfigInternalSync(): VikeConfigInternal;
 declare function getVikeConfig(config: ResolvedConfig | UserConfig): VikeConfig;
 type VikeConfig = Pick<VikeConfigInternal, 'config' | 'pages' | 'prerenderContext'>;
 declare function setVikeConfigContext(vikeConfigCtx_: VikeConfigContext): void;
+declare function isVikeConfigContextSet(): boolean;
 declare function getVikeConfigInternalOptional(): Promise<null | VikeConfigInternal>;
 declare function isV1Design(): boolean;
 declare function getVikeConfigFromCliOrEnv(): {

package/dist/esm/node/vite/shared/resolveVikeConfigInternal.js

@@ -5,6 +5,7 @@ export { getVikeConfigInternal };
 export { getVikeConfigInternalOptional };
 export { getVikeConfigInternalSync };
 export { setVikeConfigContext };
+export { isVikeConfigContextSet };
 export { reloadVikeConfig };
 export { isV1Design };
 export { getConfVal };
@@ -83,6 +84,9 @@ function setVikeConfigContext(vikeConfigCtx_) {
     // If the user changes Vite's `config.root` => Vite completely reloads itself => setVikeConfigContext() is called again
     globalObject.vikeConfigCtx = vikeConfigCtx_;
 }
+function isVikeConfigContextSet() {
+    return !!globalObject.vikeConfigCtx;
+}
 async function getOrResolveVikeConfig(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
     if (!globalObject.vikeConfigPromise) {
         resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError);

package/dist/esm/node/vite/utils.d.ts

@@ -20,3 +20,4 @@ export * from '../../utils/isVitest.js';
 export * from '../../utils/rollupSourceMap.js';
 export * from '../../utils/isImportPath.js';
 export * from '../../utils/virtualFileId.js';
+export * from '../../utils/isExactlyOneTruthy.js';

package/dist/esm/node/vite/utils.js

@@ -27,3 +27,4 @@ export * from '../../utils/isVitest.js';
 export * from '../../utils/rollupSourceMap.js';
 export * from '../../utils/isImportPath.js';
 export * from '../../utils/virtualFileId.js';
+export * from '../../utils/isExactlyOneTruthy.js';

package/dist/esm/shared/modifyUrlSameOrigin.js

@@ -1,12 +1,12 @@
 export { modifyUrlSameOrigin };
 // We don't move modifyUrlSameOrigin() to the modifyUrl.ts file because we plan to use modifyUrlSameOrigin() on the client-side:
 // https://github.com/vikejs/vike/blob/c5a2de5e85262771f97851767c00ac35da69c64b/packages/vike/client/runtime-client-routing/navigate.ts#L4
-import { createUrlFromComponents, isNotNullish_keyVal, parseUrl, objectFilter, assertUsageUrlPathnameAbsolute, } from './utils.js';
+import { createUrlFromComponents, isNotNullish_keyVal, parseUrl, objectFilter, assertUsageUrlPathAbsolute, } from './utils.js';
 function modifyUrlSameOrigin(url, modify) {
     const urlParsed = parseUrl(url, '/');
     // Pathname
     const pathname = modify.pathname ?? urlParsed.pathnameOriginal;
-    assertUsageUrlPathnameAbsolute(pathname, 'modify.pathname');
+    assertUsageUrlPathAbsolute(pathname, 'modify.pathname');
     // Search
     let search = modify.search === null ? '' : !modify.search ? urlParsed.searchOriginal : resolveSearch(urlParsed, modify.search);
     if (search === '?')

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

@@ -8,7 +8,7 @@ export { getPageContextFromAllRewrites };
 export { AbortRender };
 export { assertNoInfiniteAbortLoop };
 import { isUserHookError } from '../hooks/execHook.js';
-import { assert, assertInfo, assertUsage, assertUsageUrlPathnameAbsolute, assertUsageUrlRedirectTarget, assertWarning, checkType, hasProp, isBrowser, joinEnglish, objectAssign, truncateString, } from './utils.js';
+import { assert, assertInfo, assertUsage, assertUsageUrlPathAbsolute, assertUsageUrlRedirectTarget, assertWarning, checkType, hasProp, isBrowser, joinEnglish, objectAssign, truncateString, } from './utils.js';
 import pc from '@brillout/picocolors';
 /**
  * Abort the rendering of the current page, and redirect the user to another URL instead.
@@ -66,7 +66,7 @@ function render_(urlOrStatusCode, abortReason, abortCall, abortCaller, pageConte
     }
     if (typeof urlOrStatusCode === 'string') {
         const url = urlOrStatusCode;
-        assertUsageUrlPathnameAbsolute(url, getErrPrefix(abortCaller));
+        assertUsageUrlPathAbsolute(url, getErrPrefix(abortCaller));
         objectAssign(pageContextAbort, {
             _urlRewrite: url,
         });

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

@@ -1,6 +1,6 @@
 export { execHookOnBeforeRoute };
 import { assertPageContextProvidedByUser } from '../assertPageContextProvidedByUser.js';
-import { assertUsage, hasProp, isObjectWithKeys, objectAssign, assertWarning, assertUsageUrlPathnameAbsolute, joinEnglish, assert, } from './utils.js';
+import { assertUsage, hasProp, isObjectWithKeys, objectAssign, assertWarning, assertUsageUrlAbsolute, joinEnglish, assert, } from './utils.js';
 import { assertRouteParams, assertSyncRouting } from './resolveRouteFunction.js';
 import pc from '@brillout/picocolors';
 import { execHookDirectSync } from '../hooks/execHook.js';
@@ -65,8 +65,8 @@ async function getPageContextFromHook(onBeforeRouteHook, pageContext) {
         delete hookReturn.pageContext.urlOriginal;
     }
     if (hasProp(hookReturn.pageContext, 'urlLogical')) {
-        assertUsageUrlPathnameAbsolute(
-        // We skip validation and type-cast instead of assertUsage() in order to save client-side KBs
+        assertUsageUrlAbsolute(
+        // We type-cast instead of assertUsage() validation in order to save client-side KBs
         hookReturn.pageContext.urlLogical, `${errPrefix} returned ${pc.cyan('{ pageContext: { urlLogical } }')} and ${pc.cyan('urlLogical')}`);
     }
     assertPageContextProvidedByUser(hookReturn.pageContext, {

package/dist/esm/types/index.d.ts

@@ -13,6 +13,7 @@ export type { VikeConfig } from '../node/vite/shared/resolveVikeConfigInternal.j
 export type { UrlPublic as Url } from '../utils/parseUrl.js';
 export type { InjectFilterEntry } from '../node/runtime/renderPage/html/injectAssets/getHtmlTags.js';
 export { defineConfig } from './defineConfig.js';
+export type { _LoadDeclareGlobal__VIKE__IS } from '../node/vite/plugins/pluginReplaceConstantsGlobalThis.js';
 import type { ConfigEnv } from './PageConfig.js';
 /** @deprecated Replace:
  *   `import type { Env } from 'vike/types'`

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

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.241";
+export declare const PROJECT_VERSION: "0.4.242-commit-4a9fae0";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.241';
+export const PROJECT_VERSION = '0.4.242-commit-4a9fae0';

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

@@ -0,0 +1 @@
+export declare function isExactlyOneTruthy(...values: unknown[]): boolean;

package/dist/esm/utils/isExactlyOneTruthy.js

@@ -0,0 +1,4 @@
+// Aka XOR
+export function isExactlyOneTruthy(...values) {
+    return values.filter(Boolean).length === 1;
+}

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

@@ -1,5 +1,6 @@
 export { parseUrl };
-export { assertUsageUrlPathnameAbsolute };
+export { assertUsageUrlAbsolute };
+export { assertUsageUrlPathAbsolute };
 export { assertUsageUrlRedirectTarget };
 export { isUrl };
 export { isUri };
@@ -52,5 +53,6 @@ declare function isUrlRedirectTarget(url: string): boolean;
 declare function isUrlRelative(url: string): boolean;
 declare function isUrlExternal(url: string): boolean;
 declare function isUri(uri: string): boolean;
-declare function assertUsageUrlPathnameAbsolute(url: string, errPrefix: string): void;
+declare function assertUsageUrlAbsolute(url: string, errPrefix: string): void;
+declare function assertUsageUrlPathAbsolute(url: string, errPrefix: string): void;
 declare function assertUsageUrlRedirectTarget(url: string, errPrefix: string, isUnresolved?: true): void;