vike 0.4.142 → 0.4.143-commit-dc6fea0

package/dist/esm/shared/route/executeGuardHook.d.ts

@@ -1,8 +1,8 @@
 export { executeGuardHook };
 import type { PageContextExports, PageFile } from '../getPageFiles.js';
-import type { PageConfig } from '../page-configs/PageConfig.js';
+import type { PageConfigRuntime } from '../page-configs/PageConfig.js';
 declare function executeGuardHook<T extends PageContextExports & {
     _pageId: string;
     _pageFilesAll: PageFile[];
-    _pageConfigs: PageConfig[];
+    _pageConfigs: PageConfigRuntime[];
 }>(pageContext: T, prepareForUserConsumption: (pageConfig: T) => T | void): Promise<void>;

package/dist/esm/shared/route/index.d.ts

@@ -4,12 +4,12 @@ import type { PageFile } from '../getPageFiles.js';
 import { PageContextUrlComputedPropsInternal, PageContextUrlSources } from '../addUrlComputedProps.js';
 import { type OnBeforeRouteHook } from './executeOnBeforeRouteHook.js';
 import type { PageRoutes, RouteType } from './loadPageRoutes.js';
-import type { PageConfig, PageConfigGlobal } from '../page-configs/PageConfig.js';
+import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../page-configs/PageConfig.js';
 type PageContextForRoute = PageContextUrlComputedPropsInternal & {
     _pageFilesAll: PageFile[];
-    _pageConfigs: PageConfig[];
+    _pageConfigs: PageConfigRuntime[];
     _allPageIds: string[];
-    _pageConfigGlobal: PageConfigGlobal;
+    _pageConfigGlobal: PageConfigGlobalRuntime;
     _pageRoutes: PageRoutes;
     _onBeforeRouteHook: OnBeforeRouteHook | null;
 } & PageContextUrlSources;

package/dist/esm/shared/route/loadPageRoutes.d.ts

@@ -3,7 +3,7 @@ export type { PageRoutes };
 export type { RouteType };
 import type { PageFile } from '../getPageFiles.js';
 import type { OnBeforeRouteHook } from './executeOnBeforeRouteHook.js';
-import type { PageConfig, PageConfigGlobal } from '../page-configs/PageConfig.js';
+import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../page-configs/PageConfig.js';
 type PageRoute = {
     pageId: string;
     comesFromV1PageConfig: boolean;
@@ -23,7 +23,7 @@ type PageRoute = {
 });
 type PageRoutes = PageRoute[];
 type RouteType = 'STRING' | 'FUNCTION' | 'FILESYSTEM';
-declare function loadPageRoutes(pageFilesAll: PageFile[], pageConfigs: PageConfig[], pageConfigGlobal: PageConfigGlobal, allPageIds: string[]): Promise<{
+declare function loadPageRoutes(pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[], pageConfigGlobal: PageConfigGlobalRuntime, allPageIds: string[]): Promise<{
     pageRoutes: PageRoutes;
     onBeforeRouteHook: null | OnBeforeRouteHook;
 }>;

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

@@ -137,19 +137,17 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
 function getGlobalHooks(pageFilesAll, pageConfigs, pageConfigGlobal) {
     // V1 Design
     if (pageConfigs.length > 0) {
-        if (pageConfigGlobal.onBeforeRoute) {
-            const hookFn = pageConfigGlobal.onBeforeRoute.value;
-            if (hookFn) {
-                assert(!pageConfigGlobal.onBeforeRoute.isComputed);
-                const hookFilePath = pageConfigGlobal.onBeforeRoute.definedAtInfo.filePath;
-                assert(hookFilePath);
-                assertUsage(isCallable(hookFn), `The hook onBeforeRoute() defined by ${hookFilePath} should be a function.`);
-                const onBeforeRouteHook = {
-                    hookFilePath: hookFilePath,
-                    onBeforeRoute: hookFn
-                };
-                return { onBeforeRouteHook, filesystemRoots: null };
-            }
+        if (pageConfigGlobal.configValues.onBeforeRoute?.value) {
+            const { value: hookFn, definedAtInfo } = pageConfigGlobal.configValues.onBeforeRoute;
+            // config.onBeforeRoute isn't a computed nor a cumulative config => definedAtInfo should always be defined
+            assert(definedAtInfo);
+            const hookFilePath = definedAtInfo.filePath;
+            assertUsage(isCallable(hookFn), `The hook onBeforeRoute() defined by ${hookFilePath} should be a function.`);
+            const onBeforeRouteHook = {
+                hookFilePath: hookFilePath,
+                onBeforeRoute: hookFn
+            };
+            return { onBeforeRouteHook, filesystemRoots: null };
         }
         return { onBeforeRouteHook: null, filesystemRoots: null };
     }

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

@@ -1,7 +1,7 @@
 export { resolvePrecendence };
 // export type { RouteMatch }
 import { analyzeRouteString } from './resolveRouteString.js';
-import { higherFirst } from './utils.js';
+import { higherFirst, lowerFirst } from './utils.js';
 import { makeFirst } from './utils.js';
 import { isStaticRouteString } from './resolveRouteString.js';
 // See https://vike.dev/route-function#precedence
@@ -32,37 +32,58 @@ function sortMatches(routeMatch1, routeMatch2) {
     if (!routeMatch1.routeString) {
         return 0;
     }
+    /* DEBUG
+    console.log('routeMatch1.routeString', routeMatch1.routeString)
+    console.log('routeMatch2.routeString', routeMatch2.routeString)
+    console.log('parseRouteString(routeMatch1.routeString)', parseRouteString(routeMatch1.routeString))
+    console.log('parseRouteString(routeMatch2.routeString)', parseRouteString(routeMatch2.routeString))
+    //*/
     // Return route with highest number of static path segments at beginning first
     {
-        const getValue = (routeString) => analyzeRouteString(routeString).numberOfStaticSegmentsBeginning;
+        const getValue = (routeString) => analyzeRouteString(routeString).numberOfStaticPartsBeginning;
         const result = higherFirst(getValue)(routeMatch1.routeString, routeMatch2.routeString);
         if (result !== 0) {
+            /* DEBUG
+            console.log('analyzeRouteString(routeMatch1.routeString).numberOfStaticPartsBeginning', getValue(routeMatch1.routeString))
+            console.log('analyzeRouteString(routeMatch2.routeString).numberOfStaticPartsBeginning', getValue(routeMatch2.routeString))
+            //*/
             return result;
         }
     }
     // Return route with highest number of static path segments in total first
     {
-        const getValue = (routeString) => analyzeRouteString(routeString).numberOfStaticSegements;
+        const getValue = (routeString) => analyzeRouteString(routeString).numberOfStaticParts;
         const result = higherFirst(getValue)(routeMatch1.routeString, routeMatch2.routeString);
         if (result !== 0) {
+            /* DEBUG
+            console.log('analyzeRouteString(routeMatch1.routeString).numberOfStaticParts', getValue(routeMatch1.routeString))
+            console.log('analyzeRouteString(routeMatch2.routeString).numberOfStaticParts', getValue(routeMatch2.routeString))
+            //*/
             return result;
         }
     }
-    // Return route with most parameter segements first
+    // Return route with least amount of globs first
     {
-        const getValue = (routeString) => analyzeRouteString(routeString).numberOfParameterSegments;
-        const result = higherFirst(getValue)(routeMatch1.routeString, routeMatch2.routeString);
+        const getValue = (routeString) => analyzeRouteString(routeString).numberOfGlobs;
+        const result = lowerFirst(getValue)(routeMatch1.routeString, routeMatch2.routeString);
         if (result !== 0) {
+            /* DEBUG
+            console.log('analyzeRouteString(routeMatch1.routeString).numberOfGlobs', getValue(routeMatch1.routeString))
+            console.log('analyzeRouteString(routeMatch2.routeString).numberOfGlobs', getValue(routeMatch2.routeString))
+            //*/
             return result;
         }
     }
-    // Return catch-all routes last
+    // Return route with highest number of parameters first
     {
-        if (analyzeRouteString(routeMatch2.routeString).isCatchAll) {
-            return -1;
-        }
-        if (analyzeRouteString(routeMatch1.routeString).isCatchAll) {
-            return 1;
+        const getValue = (routeString) => analyzeRouteString(routeString).numberOfParams;
+        const result = higherFirst(getValue)(routeMatch1.routeString, routeMatch2.routeString);
+        if (result !== 0) {
+            /* DEBUG
+            console.log('analyzeRouteString(routeMatch1.routeString).numberOfParams', getValue(routeMatch1.routeString))
+            console.log('analyzeRouteString(routeMatch2.routeString).numberOfParams', getValue(routeMatch2.routeString))
+            //*/
+            return result;
         }
     }
     return 0;

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

@@ -7,7 +7,7 @@ import { assertRouteString, resolveRouteString } from './resolveRouteString.js';
 import pc from '@brillout/picocolors';
 assertIsNotBrowser(); // Don't bloat the client
 // TODO/v1-release: update
-const configSrc = '[vite.config.js > ssr({ redirects })]';
+const configSrc = '[vite.config.js > vike({ redirects })]';
 function resolveRedirects(redirects, urlPathname) {
     for (const [urlSource, urlTarget] of Object.entries(redirects)) {
         const urlResolved = resolveRouteStringRedirect(urlSource, urlTarget, urlPathname);

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

@@ -20,6 +20,7 @@ async function resolveRouteFunction(routeFunction, pageContext, routeDefinedAt)
         result = {};
     }
     assertUsage(isPlainObject(result), `The Route Function ${routeDefinedAt} should return a boolean or a plain JavaScript object (but it's ${pc.cyan(`typeof result === ${JSON.stringify(typeof result)}`)} instead)`);
+    // AFAICT this return interface is superfluous. Should we soft-deprecate it and remove it?
     if ('match' in result) {
         const { match } = result;
         assertUsage(typeof match === 'boolean', `The ${pc.cyan('match')} value returned by the Route Function ${routeDefinedAt} should be a boolean.`);

package/dist/esm/shared/route/resolveRouteString.d.ts

@@ -3,15 +3,32 @@ export { getUrlFromRouteString };
 export { isStaticRouteString };
 export { analyzeRouteString };
 export { assertRouteString };
+export { parseRouteString };
 declare function assertRouteString(routeString: string, errPrefix?: `${string}Invalid` | `${string}invalid`): void;
 declare function resolveRouteString(routeString: string, urlPathname: string): null | {
     routeParams: Record<string, string>;
 };
+type Segment = {
+    glob: true;
+    /** Make route /a/* match URL /a */
+    isLastDir?: true;
+    static?: undefined;
+    param?: undefined;
+} | {
+    glob?: undefined;
+    static: string;
+    param?: undefined;
+} | {
+    glob?: undefined;
+    static?: undefined;
+    param: string;
+};
+declare function parseRouteString(routeString: string): Segment[];
 declare function getUrlFromRouteString(routeString: string): null | string;
 declare function analyzeRouteString(routeString: string): {
-    numberOfParameterSegments: number;
-    numberOfStaticSegmentsBeginning: number;
-    numberOfStaticSegements: number;
-    isCatchAll: boolean;
+    numberOfStaticPartsBeginning: number;
+    numberOfStaticParts: number;
+    numberOfParams: number;
+    numberOfGlobs: number;
 };
 declare function isStaticRouteString(routeString: string): boolean;

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

@@ -3,48 +3,109 @@ export { getUrlFromRouteString };
 export { isStaticRouteString };
 export { analyzeRouteString };
 export { assertRouteString };
-import { assertWarning, isBrowser } from '../utils.js';
+export { parseRouteString };
+import { assertWarning, isBrowser, escapeRegex } from '../utils.js';
 import { assert, assertUsage } from './utils.js';
 import pc from '@brillout/picocolors';
 const PARAM_TOKEN_NEW = '@';
 // TODO/v1-release: remove
 const PARAM_TOKEN_OLD = ':';
 function assertRouteString(routeString, errPrefix = 'Invalid') {
-    assert(errPrefix.endsWith('Invalid') || errPrefix.endsWith('invalid'));
-    assertUsage(routeString !== '', `${errPrefix} Route String ${highlight(routeString)} (empty string): set it to ${highlight('/')} instead`);
-    assertUsage(routeString.startsWith('/') || routeString === '*', `${errPrefix} Route String ${highlight(routeString)}: Route Strings should start with a leading slash ${highlight('/')} (or be ${highlight('*')})`);
+    let errPrefix2 = `${errPrefix} Route String ${highlight(routeString)}`;
+    assertUsage(routeString !== '', `${errPrefix2} (empty string): set it to ${highlight('/')} instead`);
+    assertUsage(['/', '*'].includes(routeString[0]), `${errPrefix2}: it should start with ${highlight('/')} or ${highlight('*')}`);
+    assertUsage(!routeString.includes('**'), `${errPrefix2}: set it to ${highlight(routeString.split('**').join('*'))} instead`);
 }
 function resolveRouteString(routeString, urlPathname) {
     assertRouteString(routeString);
-    assert(urlPathname.startsWith('/'));
-    const routeSegments = routeString.split('/');
-    const urlSegments = urlPathname.split('/');
-    const routeParams = {};
-    assertGlob(routeString);
-    if (routeString === '*') {
-        routeString = '/*';
-    }
-    for (let i = 0; i < Math.max(routeSegments.length, urlSegments.length); i++) {
-        const routeSegment = routeSegments[i];
-        const urlSegment = urlSegments[i];
-        if (routeSegment === '*') {
-            routeParams['*'] = urlSegments.slice(Math.max(1, i)).join('/');
-            return { routeParams };
+    const segments = parseRouteString(routeString);
+    const routeRegexStrInner = segments
+        .map((segment) => {
+        if (segment.param) {
+            return '[^/]+';
         }
-        else if (routeSegment && isParam(routeSegment)) {
-            assertWarning(!routeSegment.startsWith(PARAM_TOKEN_OLD), `Outdated Route String ${pc.cyan(routeString)}, use ${pc.cyan(routeString.split(PARAM_TOKEN_OLD).join(PARAM_TOKEN_NEW))} instead.`, { onlyOnce: true });
-            if (!urlSegment) {
-                return null;
+        if (segment.glob) {
+            if (segment.isLastDir) {
+                return '|/.*';
+            }
+            else {
+                return '.*';
             }
-            routeParams[routeSegment.slice(1)] = urlSegment;
+        }
+        // segment.static
+        return escapeRegex(segment.static);
+    })
+        .map((s) => `(${s})`)
+        .join('');
+    const routeRegex = new RegExp(`^${routeRegexStrInner}/?$`);
+    const routeRegexMatch = urlPathname.match(routeRegex);
+    /* DEBUG
+    console.log()
+    console.log('routeString', routeString)
+    console.log('urlPathname', urlPathname)
+    console.log('routeSegments', segments)
+    console.log('routeRegex', routeRegex)
+    console.log('routeRegexMatch', routeRegexMatch)
+    //*/
+    if (!routeRegexMatch)
+        return null;
+    const routeParams = {};
+    const [_, ...segmentsValue] = routeRegexMatch;
+    let globIdx = 0;
+    const hasMultipleGlobs = segments.filter((segment) => segment.glob).length > 1;
+    segments.forEach((segment, i) => {
+        let val = segmentsValue[i];
+        if (segment.param) {
+            routeParams[segment.param] = val;
+        }
+        if (segment.glob) {
+            const param = `*${hasMultipleGlobs ? ++globIdx : ''}`;
+            if (segment.isLastDir)
+                val = val.slice(1);
+            routeParams[param] = val;
+        }
+    });
+    return { routeParams };
+}
+function parseRouteString(routeString) {
+    const segments = [];
+    const pushStatic = (s) => {
+        const segmentLast = segments[segments.length - 1];
+        if (segmentLast?.static) {
+            segmentLast.static += s;
         }
         else {
-            if ((routeSegment || '') !== (urlSegment || '')) {
-                return null;
+            segments.push({ static: s });
+        }
+    };
+    const parts = routeString.split('/');
+    parts.forEach((s, i) => {
+        const isFirst = i === 0;
+        const isLast = i === parts.length - 1;
+        if (isParam(s)) {
+            assertWarning(!s.startsWith(PARAM_TOKEN_OLD), `Outdated Route String ${highlight(routeString)}, use ${highlight(routeString.split(PARAM_TOKEN_OLD).join(PARAM_TOKEN_NEW))} instead`, { onlyOnce: true });
+            if (!isFirst)
+                pushStatic('/');
+            segments.push({ param: s.slice(1) });
+        }
+        else {
+            if (s === '*' && isLast && routeString !== '*' && routeString !== '/*') {
+                segments.push({ glob: true, isLastDir: true });
+            }
+            else {
+                if (!isFirst)
+                    pushStatic('/');
+                s.split('*').forEach((s, i) => {
+                    if (i !== 0)
+                        segments.push({ glob: true });
+                    if (s !== '') {
+                        pushStatic(s);
+                    }
+                });
             }
         }
-    }
-    return { routeParams };
+    });
+    return segments;
 }
 function getUrlFromRouteString(routeString) {
     assert(routeString.startsWith('/'));
@@ -54,24 +115,19 @@ function getUrlFromRouteString(routeString) {
     }
     return null;
 }
-function assertGlob(routeString) {
-    const numberOfGlobChars = routeString.split('*').length - 1;
-    assertUsage(numberOfGlobChars <= 1, `Invalid Route String ${highlight(routeString)}: Route Strings aren't allowed to contain more than one glob ${highlight('*')} (use a Route Function instead)`);
-    assertUsage(numberOfGlobChars === 0 || (numberOfGlobChars === 1 && routeString.endsWith('*')), `Invalid Route String ${highlight(routeString)}: make sure it ends with ${highlight('*')} or use a Route Function`);
-}
 function analyzeRouteString(routeString) {
-    const routeSegments = routeString.split('/').filter((routeSegment) => routeSegment !== '' && routeSegment !== '*');
-    let numberOfStaticSegmentsBeginning = 0;
-    for (const routeSegment of routeSegments) {
-        if (isParam(routeSegment)) {
+    const segments = parseRouteString(routeString);
+    const countStaticParts = (s) => s?.split('/').filter(Boolean).length || 0;
+    let numberOfStaticPartsBeginning = 0;
+    for (const segment of segments) {
+        if (!segment.static)
             break;
-        }
-        numberOfStaticSegmentsBeginning++;
+        numberOfStaticPartsBeginning += countStaticParts(segment.static);
     }
-    const numberOfStaticSegements = routeSegments.filter((s) => !isParam(s)).length;
-    const numberOfParameterSegments = routeSegments.filter((s) => isParam(s)).length;
-    const isCatchAll = routeString.endsWith('*');
-    return { numberOfParameterSegments, numberOfStaticSegmentsBeginning, numberOfStaticSegements, isCatchAll };
+    const numberOfStaticParts = segments.map((s) => countStaticParts(s.static)).reduce((sum, a) => sum + a, 0);
+    const numberOfParams = segments.filter((s) => s.param).length;
+    const numberOfGlobs = segments.filter((s) => s.glob).length;
+    return { numberOfStaticPartsBeginning, numberOfStaticParts, numberOfParams, numberOfGlobs };
 }
 function isParam(routeSegment) {
     return routeSegment.startsWith(PARAM_TOKEN_NEW) || routeSegment.startsWith(PARAM_TOKEN_OLD);

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

@@ -12,18 +12,17 @@ import type { ConfigEntries, ExportsAll } from './getPageFiles/getExports.js';
 import type { Config } from './page-configs/Config.js';
 import type { PageContextConfig } from './page-configs/Config/PageContextConfig.js';
 import type { AbortStatusCode } from './route/abort.js';
-type PageContext = PageContextWithClientRouting;
-type PageContextClient = PageContextClientWithClientRouting;
-type PageContextWithClientRouting = PageContextClientWithClientRouting | PageContextServer;
-type PageContextWithServerRouting = PageContextClientWithServerRouting | PageContextServer;
 type PageContextServer = PageContextBuiltInServer & Vike.PageContext;
-type PageContextClientWithClientRouting = PageContextBuiltInClientWithClientRouting & Vike.PageContext;
+type PageContext = PageContextClient | PageContextServer;
+type PageContextClient = PageContextBuiltInClientWithClientRouting & Vike.PageContext;
+type PageContextWithServerRouting = PageContextClientWithServerRouting | PageContextServer;
 type PageContextClientWithServerRouting = PageContextBuiltInClientWithServerRouting & Vike.PageContext;
 /** Built-in `pageContext` properties set by vike.
  *
  * https://vike.dev/pageContext
  */
 type PageContextBuiltInServer<Page = [never]> = PageContextBuiltInCommon<Page> & PageContextUrlComputedPropsServer;
+/** For Vike internal use */
 type PageContextBuiltInServerInternal<Page = [never]> = PageContextBuiltInCommon<Page> & PageContextUrlComputedPropsInternal;
 type PageContextBuiltInCommon<Page = [never]> = {
     /** The `export { Page }` of your `.page.js` file.
@@ -57,7 +56,10 @@ type PageContextBuiltInCommon<Page = [never]> = {
      * https://vike.dev/exports
      */
     exportsAll: ExportsAll;
-    /** The URL of the current page */
+    /** The URL you provided to Vike when calling `renderPage({ urlOriginal })` in your server middleware.
+     *
+     * https://vike.dev/renderPage
+     */
     urlOriginal: string;
     /** If an error occurs, whether the error is a `404 Page Not Found`.
      *

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

@@ -18,6 +18,6 @@ export * from '../utils/projectInfo.js';
 export * from '../utils/hasPropertyGetter.js';
 export * from '../utils/isPromise.js';
 export * from '../utils/checkType.js';
-export * from '../utils/assertDefaultExport.js';
 export * from '../utils/objectEntries.js';
 export * from '../utils/getValuePrintable.js';
+export * from '../utils/escapeRegex.js';

package/dist/esm/shared/utils.js

@@ -22,6 +22,6 @@ export * from '../utils/projectInfo.js';
 export * from '../utils/hasPropertyGetter.js';
 export * from '../utils/isPromise.js';
 export * from '../utils/checkType.js';
-export * from '../utils/assertDefaultExport.js';
 export * from '../utils/objectEntries.js';
 export * from '../utils/getValuePrintable.js';
+export * from '../utils/escapeRegex.js';

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

@@ -0,0 +1,3 @@
+export { defineConfig };
+import type { Config } from '../shared/page-configs/Config.js';
+declare function defineConfig(config: Config): Config;

package/dist/esm/types/defineConfig.js

@@ -0,0 +1,4 @@
+export { defineConfig };
+function defineConfig(config) {
+    return config;
+}

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

@@ -6,11 +6,13 @@ export type { PageContextClientWithServerRouting } from '../shared/types.js';
 export type { PageContextBuiltInServer } from '../shared/types.js';
 export type { PageContextBuiltInClientWithClientRouting } from '../shared/types.js';
 export type { PageContextBuiltInClientWithServerRouting } from '../shared/types.js';
-export type { Config, ConfigMeta as Meta } from '../shared/page-configs/Config.js';
+export type { Config, ConfigMeta as Meta, GuardAsync, GuardSync, OnBeforePrerenderStartAsync, OnBeforePrerenderStartSync, OnBeforeRenderAsync, OnBeforeRenderSync, OnBeforeRouteAsync, OnBeforeRouteSync, OnHydrationEndAsync, OnHydrationEndSync, OnPageTransitionEndAsync, OnPageTransitionEndSync, OnPageTransitionStartAsync, OnPageTransitionStartSync, OnPrerenderStartAsync, OnPrerenderStartSync, OnRenderClientAsync, OnRenderClientSync, OnRenderHtmlAsync, OnRenderHtmlSync, RouteAsync, RouteSync } from '../shared/page-configs/Config.js';
 export type { ConfigEnv } from '../shared/page-configs/PageConfig.js';
 export type { ConfigDefinition, ConfigEffect } from '../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
 export type { ConfigEntries } from '../shared/getPageFiles/getExports.js';
+export type { Url } from '../shared/addUrlComputedProps.js';
 export type { InjectFilterEntry } from '../node/runtime/html/injectAssets/getHtmlTags.js';
+export { defineConfig } from './defineConfig.js';
 import type { ConfigEnv } from '../shared/page-configs/PageConfig.js';
 /** @deprecated Replace:
  *   `import type { Env } from 'vike/types'`

package/dist/esm/types/index.js

@@ -1 +1 @@
-export {};
+export { defineConfig } from './defineConfig.js';

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

@@ -1,5 +1,5 @@
 export { getFilePathAbsolute };
-export { getFilePathVite };
+export { getFilePathRelativeToUserRootDir };
 import type { ResolvedConfig } from 'vite';
 declare function getFilePathAbsolute(filePath: string, config: ResolvedConfig): string;
-declare function getFilePathVite(filePath: string, userRootDir: string, alwaysRelativeToRoot?: boolean): string;
+declare function getFilePathRelativeToUserRootDir(filePathAbsolute: string, userRootDir: string, alwaysRelative?: boolean): string;

package/dist/esm/utils/getFilePathAbsolute.js

@@ -1,5 +1,5 @@
 export { getFilePathAbsolute };
-export { getFilePathVite };
+export { getFilePathRelativeToUserRootDir };
 import { assertPosixPath, toPosixPath } from './filesystemPathHandling.js';
 import { assert } from './assert.js';
 import path from 'path';
@@ -42,19 +42,23 @@ function getFilePathAbsolute(filePath, config) {
     assertPathIsFilesystemAbsolute(filePathAbsolute);
     return filePathAbsolute;
 }
-function getFilePathVite(filePath, userRootDir, alwaysRelativeToRoot = false) {
-    assertPosixPath(filePath);
+function getFilePathRelativeToUserRootDir(filePathAbsolute, userRootDir, alwaysRelative = false) {
+    assertPosixPath(filePathAbsolute);
     assertPosixPath(userRootDir);
-    const filePathRelativeToRoot = path.posix.relative(userRootDir, filePath);
-    if (!filePath.startsWith(userRootDir)) {
-        if (alwaysRelativeToRoot) {
-            return filePathRelativeToRoot;
+    let filePathRelativeToUserRootDir = path.posix.relative(userRootDir, filePathAbsolute);
+    if (filePathAbsolute.startsWith(userRootDir)) {
+        assert(!filePathRelativeToUserRootDir.startsWith('.') && !filePathRelativeToUserRootDir.startsWith('/'), 
+        // Surprinsingly, this assertion seem to fail sometimes: https://github.com/vikejs/vike/issues/1139
+        { filePathRelativeToUserRootDir, filePathAbsolute, userRootDir });
+        filePathRelativeToUserRootDir = `/${filePathRelativeToUserRootDir}`;
+        return filePathRelativeToUserRootDir;
+    }
+    else {
+        if (alwaysRelative) {
+            return filePathRelativeToUserRootDir;
         }
         else {
-            return filePath;
+            return filePathAbsolute;
         }
     }
-    assert(!filePathRelativeToRoot.startsWith('.') && !filePathRelativeToRoot.startsWith('/'));
-    const filePathVite = `/${filePathRelativeToRoot}`;
-    return filePathVite;
 }

package/dist/esm/utils/objectAssign.js

@@ -3,5 +3,7 @@ export { objectAssign };
 //  - With type inference
 //  - Preserves property descriptors, which we need for preserving the getters added by addUrlComputedProps()
 function objectAssign(obj, objAddendum) {
-    Object.defineProperties(obj, Object.getOwnPropertyDescriptors(objAddendum));
+    if (objAddendum) {
+        Object.defineProperties(obj, Object.getOwnPropertyDescriptors(objAddendum));
+    }
 }

package/dist/esm/utils/parseUrl.js

@@ -110,7 +110,10 @@ function parsePathname(urlWithoutHashNorSearch, baseServer) {
     else {
         // In the browser, this is the Base URL of the current URL
         // Safe access `window?.document?.baseURI` for users who shim `window` in Node.js
-        const base = (typeof window !== 'undefined' && window?.document?.baseURI) || baseServer;
+        let baseURI = typeof window !== 'undefined' && window?.document?.baseURI;
+        if (baseURI)
+            baseURI = parseOrigin(baseURI).pathname;
+        const base = baseURI || baseServer;
         const pathname = resolveUrlPathnameRelative(urlWithoutHashNorSearch, base);
         // We need to parse the origin in case `base === window.document.baseURI`
         const parsed = parseOrigin(pathname);
@@ -153,6 +156,8 @@ function resolveUrlPathnameRelative(pathnameRelative, base) {
     let pathnameAbsolute = stack.join('/');
     if (baseRestoreTrailingSlash && !pathnameAbsolute.endsWith('/'))
         pathnameAbsolute += '/';
+    if (!pathnameAbsolute.startsWith('/'))
+        pathnameAbsolute = '/' + pathnameAbsolute;
     return pathnameAbsolute;
 }
 /* Not needed anymore?

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

@@ -5,7 +5,7 @@ type ProjectVersion = typeof projectInfo.projectVersion;
 type ProjectTag = `[${PackageName}]` | `[${PackageName}@${ProjectVersion}]`;
 declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.142";
+    projectVersion: "0.4.143-commit-dc6fea0";
     npmPackageName: "vike";
     githubRepository: "https://github.com/vikejs/vike";
 };

package/dist/esm/utils/projectInfo.js

@@ -1,6 +1,6 @@
 export { projectInfo };
 import { onProjectInfo } from './assertSingleInstance.js';
-const PROJECT_VERSION = '0.4.142';
+const PROJECT_VERSION = '0.4.143-commit-dc6fea0';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION,

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

@@ -0,0 +1,2 @@
+export { requireResolve };
+declare function requireResolve(importPath: string, cwd: string): string | null;

package/dist/esm/utils/requireResolve.js

@@ -0,0 +1,57 @@
+export { requireResolve };
+import { assert } from './assert.js';
+import { assertIsNotBrowser } from './assertIsNotBrowser.js';
+import { assertIsNotProductionRuntime } from './assertIsNotProductionRuntime.js';
+import { assertPosixPath, toPosixPath } from './filesystemPathHandling.js';
+import { scriptFileExtensionList } from './isScriptFile.js';
+import { createRequire } from 'module';
+// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+const importMetaUrl = import.meta.url;
+const require_ = createRequire(importMetaUrl);
+assertIsNotBrowser();
+assertIsNotProductionRuntime();
+function requireResolve(importPath, cwd) {
+    assertPosixPath(cwd);
+    const clean = addFileExtensionsToRequireResolve();
+    importPath = removeFileExtention(importPath);
+    let importedFile;
+    try {
+        importedFile = require_.resolve(importPath, { paths: [cwd] });
+    }
+    catch {
+        importedFile = null;
+    }
+    finally {
+        clean();
+    }
+    if (importedFile) {
+        importedFile = toPosixPath(importedFile);
+    }
+    return importedFile;
+}
+function removeFileExtention(importPath) {
+    for (const ext of scriptFileExtensionList) {
+        const suffix = `.${ext}`;
+        if (importPath.endsWith(suffix)) {
+            return importPath.slice(0, -1 * suffix.length);
+        }
+    }
+    return importPath;
+}
+function addFileExtensionsToRequireResolve() {
+    const added = [];
+    scriptFileExtensionList.forEach((ext) => {
+        assert(!ext.includes('.'));
+        ext = `.${ext}`;
+        if (!require.extensions[ext]) {
+            require.extensions[ext] = require.extensions['.js'];
+            added.push(ext);
+        }
+    });
+    const clean = () => {
+        added.forEach((ext) => {
+            delete require.extensions[ext];
+        });
+    };
+    return clean;
+}