vike 0.4.241 → 0.4.242-commit-33026dc

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';
@@ -142,7 +142,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 +150,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 +161,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/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-33026dc";

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-33026dc';

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;

package/dist/esm/utils/parseUrl.js

@@ -3,7 +3,8 @@
 //  - It doesn't support the tauri:// protocol
 // Unit tests at ./parseUrl.spec.ts
 export { parseUrl };
-export { assertUsageUrlPathnameAbsolute };
+export { assertUsageUrlAbsolute };
+export { assertUsageUrlPathAbsolute };
 export { assertUsageUrlRedirectTarget };
 export { isUrl };
 export { isUri };
@@ -135,7 +136,7 @@ function getBaseURI() {
     return baseURI;
 }
 function parseOrigin(url) {
-    if (!isUrlWithProtocol(url)) {
+    if (!isUrlWithWebProtocol(url)) {
         return { pathname: url, origin: null, protocol: null };
     }
     else {
@@ -181,7 +182,7 @@ function parseProtocol(uri) {
     }
     return { protocol, uriWithoutProtocol };
 }
-function isUrlProtocol(protocol) {
+function isWebUrlProtocol(protocol) {
     // Is there an alternative to having a blocklist?
     // - If the blocklist becomes too big, maybe use a allowlist instead ['tauri://', 'file://', 'capacitor://', 'http://', 'https://']
     const blocklist = [
@@ -264,10 +265,16 @@ function createUrlFromComponents(origin, pathname, search, hash) {
 }
 function isUrl(url) {
     // parseUrl() works with these URLs
-    return isUrlWithProtocol(url) || url.startsWith('/') || isUrlRelative(url);
+    return isUrlAbsolute(url) || isUrlRelative(url);
 }
 function isUrlRedirectTarget(url) {
-    return url.startsWith('/') || isUri(url) || isUrlWithProtocol(url);
+    return isUrlAbsolute(url) || isUri(url);
+}
+function isUrlAbsolute(url) {
+    return isUrlPathAbsolute(url) || isUrlWithWebProtocol(url);
+}
+function isUrlPathAbsolute(url) {
+    return url.startsWith('/');
 }
 function isUrlRelative(url) {
     return ['.', '?', '#'].some((c) => url.startsWith(c)) || url === '';
@@ -288,9 +295,9 @@ URL with protocol.
 [Electron (`file://`)](https://github.com/vikejs/vike/issues/1557)
 [Capacitor](https://github.com/vikejs/vike/issues/1706)
  */
-function isUrlWithProtocol(url) {
+function isUrlWithWebProtocol(url) {
     const { protocol } = parseProtocol(url);
-    return !!protocol && isUrlProtocol(protocol);
+    return !!protocol && isWebUrlProtocol(protocol);
 }
 /*
 URIs that aren't URLs.
@@ -308,27 +315,23 @@ We need to treat URIs differently than URLs.
 */
 function isUri(uri) {
     const { protocol } = parseProtocol(uri);
-    return !!protocol && !isUrlProtocol(uri);
+    return !!protocol && !isWebUrlProtocol(protocol);
+}
+function assertUsageUrlAbsolute(url, errPrefix) {
+    assertUsage(isUrlAbsolute(url), getErrMsg(url, errPrefix, true));
 }
-function assertUsageUrlPathnameAbsolute(url, errPrefix) {
-    assertUsageUrl(url, errPrefix);
+function assertUsageUrlPathAbsolute(url, errPrefix) {
+    assertUsage(isUrlPathAbsolute(url), getErrMsg(url, errPrefix));
 }
 function assertUsageUrlRedirectTarget(url, errPrefix, isUnresolved) {
-    assertUsageUrl(url, errPrefix, { isRedirectTarget: isUnresolved ? 'unresolved' : true });
+    const errMsg = getErrMsg(url, errPrefix, true, isUnresolved);
+    assertUsage(isUrlRedirectTarget(url) || (isUnresolved && url === '*'), errMsg);
 }
-function assertUsageUrl(url, errPrefix, { isRedirectTarget } = {}) {
-    if (url.startsWith('/'))
-        return;
+function getErrMsg(url, errPrefix, allowProtocol, allowUri) {
     let errMsg = `${errPrefix} is ${pc.string(url)} but it should start with ${pc.string('/')}`;
-    if (isRedirectTarget) {
-        if (isUrlRedirectTarget(url))
-            return;
-        errMsg += ` or a protocol (${pc.string('http://')}, ${pc.string('mailto:')}, ...)`;
-        if (isRedirectTarget === 'unresolved') {
-            if (url === '*')
-                return;
-            errMsg += `, or be ${pc.string('*')}`;
-        }
-    }
-    assertUsage(false, errMsg);
+    if (allowProtocol)
+        errMsg += ` or a protocol (e.g. ${pc.string('http://')})`;
+    if (allowUri)
+        errMsg += `, or be ${pc.string('*')}`;
+    return errMsg;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.241",
+  "version": "0.4.242-commit-33026dc",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {

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

@@ -1,10 +0,0 @@
-export { isViteCliCall };
-export { getViteConfigFromCli };
-declare function isViteCliCall(): boolean;
-type ConfigFromCli = {
-    root: undefined | string;
-    configFile: undefined | string;
-} & Record<string, unknown> & {
-    build: Record<string, unknown>;
-};
-declare function getViteConfigFromCli(): null | ConfigFromCli;