vike 0.4.142 → 0.4.143-commit-dc6fea0

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

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertRouteString = exports.analyzeRouteString = exports.isStaticRouteString = exports.getUrlFromRouteString = exports.resolveRouteString = void 0;
+exports.parseRouteString = exports.assertRouteString = exports.analyzeRouteString = exports.isStaticRouteString = exports.getUrlFromRouteString = exports.resolveRouteString = void 0;
 const utils_js_1 = require("../utils.js");
 const utils_js_2 = require("./utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
@@ -11,44 +11,105 @@ const PARAM_TOKEN_NEW = '@';
 // TODO/v1-release: remove
 const PARAM_TOKEN_OLD = ':';
 function assertRouteString(routeString, errPrefix = 'Invalid') {
-    (0, utils_js_2.assert)(errPrefix.endsWith('Invalid') || errPrefix.endsWith('invalid'));
-    (0, utils_js_2.assertUsage)(routeString !== '', `${errPrefix} Route String ${highlight(routeString)} (empty string): set it to ${highlight('/')} instead`);
-    (0, utils_js_2.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)}`;
+    (0, utils_js_2.assertUsage)(routeString !== '', `${errPrefix2} (empty string): set it to ${highlight('/')} instead`);
+    (0, utils_js_2.assertUsage)(['/', '*'].includes(routeString[0]), `${errPrefix2}: it should start with ${highlight('/')} or ${highlight('*')}`);
+    (0, utils_js_2.assertUsage)(!routeString.includes('**'), `${errPrefix2}: set it to ${highlight(routeString.split('**').join('*'))} instead`);
 }
 exports.assertRouteString = assertRouteString;
 function resolveRouteString(routeString, urlPathname) {
     assertRouteString(routeString);
-    (0, utils_js_2.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)) {
-            (0, utils_js_1.assertWarning)(!routeSegment.startsWith(PARAM_TOKEN_OLD), `Outdated Route String ${picocolors_1.default.cyan(routeString)}, use ${picocolors_1.default.cyan(routeString.split(PARAM_TOKEN_OLD).join(PARAM_TOKEN_NEW))} instead.`, { onlyOnce: true });
-            if (!urlSegment) {
-                return null;
+        if (segment.glob) {
+            if (segment.isLastDir) {
+                return '|/.*';
             }
-            routeParams[routeSegment.slice(1)] = urlSegment;
-        }
-        else {
-            if ((routeSegment || '') !== (urlSegment || '')) {
-                return null;
+            else {
+                return '.*';
             }
         }
-    }
+        // segment.static
+        return (0, utils_js_1.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 };
 }
 exports.resolveRouteString = resolveRouteString;
+function parseRouteString(routeString) {
+    const segments = [];
+    const pushStatic = (s) => {
+        const segmentLast = segments[segments.length - 1];
+        if (segmentLast?.static) {
+            segmentLast.static += s;
+        }
+        else {
+            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)) {
+            (0, utils_js_1.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 segments;
+}
+exports.parseRouteString = parseRouteString;
 function getUrlFromRouteString(routeString) {
     (0, utils_js_2.assert)(routeString.startsWith('/'));
     if (isStaticRouteString(routeString)) {
@@ -58,24 +119,19 @@ function getUrlFromRouteString(routeString) {
     return null;
 }
 exports.getUrlFromRouteString = getUrlFromRouteString;
-function assertGlob(routeString) {
-    const numberOfGlobChars = routeString.split('*').length - 1;
-    (0, utils_js_2.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)`);
-    (0, utils_js_2.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 };
 }
 exports.analyzeRouteString = analyzeRouteString;
 function isParam(routeSegment) {

package/dist/cjs/shared/utils.js

@@ -38,6 +38,6 @@ __exportStar(require("../utils/projectInfo.js"), exports);
 __exportStar(require("../utils/hasPropertyGetter.js"), exports);
 __exportStar(require("../utils/isPromise.js"), exports);
 __exportStar(require("../utils/checkType.js"), exports);
-__exportStar(require("../utils/assertDefaultExport.js"), exports);
 __exportStar(require("../utils/objectEntries.js"), exports);
 __exportStar(require("../utils/getValuePrintable.js"), exports);
+__exportStar(require("../utils/escapeRegex.js"), exports);

package/dist/cjs/types/defineConfig.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineConfig = void 0;
+function defineConfig(config) {
+    return config;
+}
+exports.defineConfig = defineConfig;

package/dist/cjs/types/index.js

@@ -1,2 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineConfig = void 0;
+var defineConfig_js_1 = require("./defineConfig.js");
+Object.defineProperty(exports, "defineConfig", { enumerable: true, get: function () { return defineConfig_js_1.defineConfig; } });

package/dist/cjs/utils/getFilePathAbsolute.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFilePathVite = exports.getFilePathAbsolute = void 0;
+exports.getFilePathRelativeToUserRootDir = exports.getFilePathAbsolute = void 0;
 const filesystemPathHandling_js_1 = require("./filesystemPathHandling.js");
 const assert_js_1 = require("./assert.js");
 const path_1 = __importDefault(require("path"));
@@ -47,20 +47,24 @@ function getFilePathAbsolute(filePath, config) {
     return filePathAbsolute;
 }
 exports.getFilePathAbsolute = getFilePathAbsolute;
-function getFilePathVite(filePath, userRootDir, alwaysRelativeToRoot = false) {
-    (0, filesystemPathHandling_js_1.assertPosixPath)(filePath);
+function getFilePathRelativeToUserRootDir(filePathAbsolute, userRootDir, alwaysRelative = false) {
+    (0, filesystemPathHandling_js_1.assertPosixPath)(filePathAbsolute);
     (0, filesystemPathHandling_js_1.assertPosixPath)(userRootDir);
-    const filePathRelativeToRoot = path_1.default.posix.relative(userRootDir, filePath);
-    if (!filePath.startsWith(userRootDir)) {
-        if (alwaysRelativeToRoot) {
-            return filePathRelativeToRoot;
+    let filePathRelativeToUserRootDir = path_1.default.posix.relative(userRootDir, filePathAbsolute);
+    if (filePathAbsolute.startsWith(userRootDir)) {
+        (0, assert_js_1.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;
         }
     }
-    (0, assert_js_1.assert)(!filePathRelativeToRoot.startsWith('.') && !filePathRelativeToRoot.startsWith('/'));
-    const filePathVite = `/${filePathRelativeToRoot}`;
-    return filePathVite;
 }
-exports.getFilePathVite = getFilePathVite;
+exports.getFilePathRelativeToUserRootDir = getFilePathRelativeToUserRootDir;

package/dist/cjs/utils/objectAssign.js

@@ -5,6 +5,8 @@ exports.objectAssign = void 0;
 //  - 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));
+    }
 }
 exports.objectAssign = objectAssign;

package/dist/cjs/utils/parseUrl.js

@@ -112,7 +112,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);
@@ -155,6 +158,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/cjs/utils/projectInfo.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.projectInfo = void 0;
 const assertSingleInstance_js_1 = require("./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/cjs/utils/requireResolve.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireResolve = void 0;
+const assert_js_1 = require("./assert.js");
+const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
+const assertIsNotProductionRuntime_js_1 = require("./assertIsNotProductionRuntime.js");
+const filesystemPathHandling_js_1 = require("./filesystemPathHandling.js");
+const isScriptFile_js_1 = require("./isScriptFile.js");
+const module_1 = require("module");
+// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+const importMetaUrl = `file://${__filename}`;
+const require_ = (0, module_1.createRequire)(importMetaUrl);
+(0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
+(0, assertIsNotProductionRuntime_js_1.assertIsNotProductionRuntime)();
+function requireResolve(importPath, cwd) {
+    (0, filesystemPathHandling_js_1.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 = (0, filesystemPathHandling_js_1.toPosixPath)(importedFile);
+    }
+    return importedFile;
+}
+exports.requireResolve = requireResolve;
+function removeFileExtention(importPath) {
+    for (const ext of isScriptFile_js_1.scriptFileExtensionList) {
+        const suffix = `.${ext}`;
+        if (importPath.endsWith(suffix)) {
+            return importPath.slice(0, -1 * suffix.length);
+        }
+    }
+    return importPath;
+}
+function addFileExtensionsToRequireResolve() {
+    const added = [];
+    isScriptFile_js_1.scriptFileExtensionList.forEach((ext) => {
+        (0, assert_js_1.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;
+}

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

@@ -1,8 +1,8 @@
 import { route, type PageRoutes } from '../shared/route/index.js';
 import { type PageFile } from '../shared/getPageFiles.js';
-import { PageConfig } from '../shared/page-configs/PageConfig.js';
+import { PageConfigRuntime } from '../shared/page-configs/PageConfig.js';
 export { route, getPagesAndRoutes };
-export type { PageRoutes, PageFile, PageConfig };
+export type { PageRoutes, PageFile, PageConfigRuntime as PageConfig };
 /**
  * Used by {@link https://github.com/magne4000/vite-plugin-vercel|vite-plugin-vercel}
  * to compute some rewrite rules and extract { isr } configs.
@@ -12,6 +12,6 @@ export type { PageRoutes, PageFile, PageConfig };
 declare function getPagesAndRoutes(): Promise<{
     pageRoutes: PageRoutes;
     pageFilesAll: PageFile[];
-    pageConfigs: PageConfig[];
+    pageConfigs: PageConfigRuntime[];
     allPageIds: string[];
 }>;

package/dist/esm/client/client-routing-runtime/createPageContext.d.ts

@@ -8,8 +8,8 @@ declare function createPageContext<T extends {
     _baseServer: string;
     _isProduction: boolean;
     _pageFilesAll: import("../../shared/getPageFiles/getPageFileObject.js").PageFile[];
-    _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfig[];
-    _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobal;
+    _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
+    _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
     _allPageIds: string[];
     _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
     _onBeforeRouteHook: import("../../shared/route/executeOnBeforeRouteHook.js").OnBeforeRouteHook | null;

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

@@ -5,7 +5,7 @@ export { isAlreadyServerSideRouted };
 import type { PageContextExports, PageFile } from '../../shared/getPageFiles.js';
 import type { PageContextUrlComputedPropsInternal } from '../../shared/addUrlComputedProps.js';
 import { PageContextForRoute } from '../../shared/route/index.js';
-import type { PageConfig } from '../../shared/page-configs/PageConfig.js';
+import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
 import type { PageContextForPassToClientWarning } from '../shared/getPageContextProxyForUser.js';
 type PageContextAddendum = {
     _pageId: string;
@@ -23,7 +23,7 @@ declare function getPageContextErrorPage(pageContext: {
     _allPageIds: string[];
     _isFirstRenderAttempt: boolean;
     _pageFilesAll: PageFile[];
-    _pageConfigs: PageConfig[];
+    _pageConfigs: PageConfigRuntime[];
 } & PageContextPassThrough): Promise<PageContextAddendum>;
 declare function checkIf404(err: unknown): boolean;
 declare function isAlreadyServerSideRouted(err: unknown): boolean;

package/dist/esm/client/client-routing-runtime/getPageId.d.ts

@@ -2,9 +2,9 @@ export { getPageId };
 declare function getPageId(url: string): Promise<{
     pageId: null;
     pageFilesAll: import("../../shared/getPageFiles/getPageFileObject.js").PageFile[];
-    pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfig[];
+    pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
 } | {
     pageId: string;
     pageFilesAll: import("../../shared/getPageFiles/getPageFileObject.js").PageFile[];
-    pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfig[];
+    pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
 }>;

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

@@ -18,7 +18,9 @@ const linkPrefetchHandlerAdded = new Map();
  * @param url - The URL of the page you want to prefetch.
  */
 async function prefetch(url) {
-    assertUsage(checkIfClientRouting(), 'prefetch() only works with Client Routing, see https://vike.dev/prefetch', { showStackTrace: true });
+    assertUsage(checkIfClientRouting(), 'prefetch() only works with Client Routing, see https://vike.dev/prefetch', {
+        showStackTrace: true
+    });
     assertUsage(!isExternalLink(url), `You are trying to prefetch the URL ${url} of another domain which cannot be prefetched`, { showStackTrace: true });
     if (isAlreadyPrefetched(url))
         return;

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

@@ -103,7 +103,7 @@ function useClientRouter() {
         // Start transition before any await's
         if (renderingNumber > 1) {
             if (isTransitioning === false) {
-                globalObject.onPageTransitionStart?.(pageContextBase);
+                await globalObject.onPageTransitionStart?.(pageContextBase);
                 isTransitioning = true;
             }
         }
@@ -265,7 +265,7 @@ function useClientRouter() {
         else if (renderingNumber === renderingCounter) {
             if (pageContext.exports.onPageTransitionEnd) {
                 assertHook(pageContext, 'onPageTransitionEnd');
-                pageContext.exports.onPageTransitionEnd(pageContext);
+                await pageContext.exports.onPageTransitionEnd(pageContext);
             }
             isTransitioning = false;
         }

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

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

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

@@ -1,11 +1,11 @@
 export { executeOnRenderClientHook };
 import type { PageFile, PageContextExports } from '../../shared/getPageFiles.js';
 import { type PageContextForUserConsumptionClientSide } from './preparePageContextForUserConsumptionClientSide.js';
-import type { PageConfig } from '../../shared/page-configs/PageConfig.js';
+import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
 declare function executeOnRenderClientHook<PC extends {
     _pageFilesLoaded: PageFile[];
     urlOriginal?: string;
     urlPathname?: string;
     _pageId: string;
-    _pageConfigs: PageConfig[];
+    _pageConfigs: PageConfigRuntime[];
 } & PageContextExports & PageContextForUserConsumptionClientSide>(pageContext: PC, isClientRouting: boolean): Promise<void>;

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

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

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

@@ -1,6 +1,6 @@
 import { getPageFilesClientSide, getExports } from '../../shared/getPageFiles.js';
 import { findPageConfig } from '../../shared/page-configs/findPageConfig.js';
-import { loadPageCode } from '../../shared/page-configs/loadPageCode.js';
+import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 export { loadPageFilesClientSide };
 export { isErrorFetchingStaticAssets };
 const stamp = '__whileFetchingAssets';
@@ -13,7 +13,7 @@ async function loadPageFilesClientSide(pageFilesAll, pageConfigs, pageId) {
     try {
         // prettier-ignore
         const result = await Promise.all([
-            pageConfig && loadPageCode(pageConfig, isDev),
+            pageConfig && loadConfigValues(pageConfig, isDev),
             ...pageFilesClientSide.map((p) => p.loadFile?.()),
         ]);
         pageConfigLoaded = result[0];

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

@@ -1,11 +1,11 @@
 export { preparePageContextForUserConsumptionClientSide };
 export type { PageContextForUserConsumptionClientSide };
 import type { PageContextExports } from '../../shared/getPageFiles.js';
-import type { PageConfig } from '../../shared/page-configs/PageConfig.js';
+import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
 import { PageContextForPassToClientWarning } from './getPageContextProxyForUser.js';
 type PageContextForUserConsumptionClientSide = PageContextExports & PageContextForPassToClientWarning & {
     _pageId: string;
-    _pageConfigs: PageConfig[];
+    _pageConfigs: PageConfigRuntime[];
 };
 declare function preparePageContextForUserConsumptionClientSide<T extends PageContextForUserConsumptionClientSide>(pageContext: T, isClientRouting: boolean): T & {
     Page: unknown;

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

@@ -1,5 +1,6 @@
 export default plugin;
 export { plugin };
+// TODO/v1-release: remove
 export { plugin as ssr };
 import { assertUsage, markEnvAsVite } from './utils.js';
 import { buildConfig } from './plugins/buildConfig.js';
@@ -48,7 +49,7 @@ function plugin(vikeConfig) {
     ];
     return plugins;
 }
-// Enable `const ssr = require('vike/plugin')`.
+// Enable `const vike = require('vike/plugin')`.
 //  - This lives at the end of the file to ensure it happens after all assignments to `exports`.
 //  - This is only used for the CJS build; we wrap it in a try-catch for the ESM build.
 try {
@@ -59,6 +60,6 @@ catch { }
 Object.defineProperty(plugin, 'apply', {
     enumerable: true,
     get: () => {
-        assertUsage(false, `Add ${pc.cyan('ssr()')} instead of ${pc.cyan('ssr')} to vite.config.js#plugins (i.e. call the function and add the return value instead of adding the function itself)`, { showStackTrace: true });
+        assertUsage(false, `Add ${pc.cyan('vike()')} instead of ${pc.cyan('vike')} to vite.config.js#plugins (i.e. call the function and add the return value instead of adding the function itself)`, { showStackTrace: true });
     }
 });

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

@@ -50,8 +50,10 @@ function buildConfig() {
         },
         async writeBundle(options, bundle) {
             const manifestEntry = bundle[manifestTempFile];
-            if (generateManifest) {
-                assert(manifestEntry);
+            /* Fails with @vitejs/plugin-legacy because writeBundle() is called twice during the client build (once for normal client assets and a second time for legacy assets), see reproduction at https://github.com/vikejs/vike/issues/1154
+            assert(generateManifest === !!manifestEntry)
+            */
+            if (manifestEntry) {
                 const { dir } = options;
                 assert(dir);
                 const manifestFilePathOld = path.join(dir, manifestEntry.fileName);
@@ -61,9 +63,6 @@ function buildConfig() {
                 const manifestFilePathNew = path.join(dir, '..', 'assets.json');
                 await fs.rename(manifestFilePathOld, manifestFilePathNew);
             }
-            else {
-                assert(!manifestEntry);
-            }
         }
     };
 }

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

@@ -14,12 +14,7 @@ function commonConfig() {
         {
             name: 'vike-commonConfig-1',
             config: () => ({
-                appType: 'custom',
-                ssr: {
-                    // Needed as long as Vike is published as CJS.
-                    // TODO: can we remove this once Vike is published as ESM?
-                    external: ['vike', 'vike/server']
-                }
+                appType: 'custom'
             }),
             configResolved(config) {
                 installRequireShim_setUserRootDir(config.root);
@@ -70,5 +65,5 @@ function assertEsm(userViteRoot) {
     }
     assert(dir.endsWith('/'));
     dir = pc.dim(dir);
-    assertWarning(packageJson.type === 'module', `We recommend setting ${dir}package.json#type to "module" (and therefore writing ESM code instead of CJS code), see https://vike.dev/CJS`, { onlyOnce: true });
+    assertWarning(packageJson.type === 'module', `We recommend setting ${dir}package.json#type to "module", see https://vike.dev/CJS`, { onlyOnce: true });
 }

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

@@ -2,7 +2,7 @@ export { determineOptimizeDeps };
 import { findPageFiles } from '../../shared/findPageFiles.js';
 import { assert, getFilePathAbsolute, isNotNullish, isNpmPackageImport, unique } from '../../utils.js';
 import { getVikeConfig } from '../importUserCode/v1-design/getVikeConfig.js';
-import { getConfigValueSourcesRelevant } from '../../shared/getConfigValueSource.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) {

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

@@ -1,6 +1,6 @@
 export { envVarsPlugin };
 import { loadEnv } from 'vite';
-import { assert, assertPosixPath, assertUsage, assertWarning, getFilePathVite, lowerFirst } from '../utils.js';
+import { assert, assertPosixPath, assertUsage, assertWarning, getFilePathRelativeToUserRootDir, lowerFirst } from '../utils.js';
 function envVarsPlugin() {
     let envsAll;
     let config;
@@ -41,11 +41,9 @@ function envVarsPlugin() {
                 if (isPrivate && isClientSide) {
                     if (!code.includes(varName))
                         return;
-                    const filePathVite = getFilePathVite(id, config.root);
-                    const errMsgAddendum = isBuild
-                        ? ''
-                        : ' (vike will prevent your app from building for production)';
-                    const errMsg = `${varName} used in ${filePathVite} 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`;
+                    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);
                     }