vike 0.4.146 → 0.4.147-commit-2fa53b2

package/dist/esm/node/runtime/renderPage.js

@@ -2,7 +2,7 @@ export { renderPage };
 export { renderPage_addWrapper };
 import { getRenderContext, getPageContextInitEnhanced, renderPageAlreadyRouted } from './renderPage/renderPageAlreadyRouted.js';
 import { route } from '../../shared/route/index.js';
-import { assert, hasProp, objectAssign, isParsable, parseUrl, assertEnv, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, addUrlOrigin } from './utils.js';
+import { assert, hasProp, objectAssign, isParsable, parseUrl, assertEnv, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, addUrlOrigin, createUrlFromComponents } from './utils.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
 import { getGlobalContext, initGlobalContext } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.js';
@@ -312,11 +312,11 @@ function skipRequest(urlOriginal) {
         isViteClientRequest);
 }
 function normalizeUrl(pageContextInit, httpRequestId) {
-    const { trailingSlash, disableUrlNormalization } = getGlobalContext();
+    const { trailingSlash, disableUrlNormalization, baseServer } = getGlobalContext();
     if (disableUrlNormalization)
         return null;
     const { urlOriginal } = pageContextInit;
-    const urlNormalized = normalizeUrlPathname(urlOriginal, trailingSlash);
+    const urlNormalized = normalizeUrlPathname(urlOriginal, trailingSlash, baseServer);
     if (!urlNormalized)
         return null;
     logRuntimeInfo?.(`URL normalized from ${pc.cyan(urlOriginal)} to ${pc.cyan(urlNormalized)} (https://vike.dev/url-normalization)`, httpRequestId, 'info');
@@ -327,10 +327,8 @@ function normalizeUrl(pageContextInit, httpRequestId) {
 function getPermanentRedirect(pageContextInit, httpRequestId) {
     const { redirects, baseServer } = getGlobalContext();
     const urlWithoutBase = removeBaseServer(pageContextInit.urlOriginal, baseServer);
-    let urlOriginalPathnameWithouBase;
     let origin = null;
     let urlTarget = modifyUrlPathname(urlWithoutBase, (urlPathname) => {
-        urlOriginalPathnameWithouBase = urlPathname;
         const urlTargetWithOrigin = resolveRedirects(redirects, urlPathname);
         if (urlTargetWithOrigin === null)
             return null;
@@ -340,13 +338,12 @@ function getPermanentRedirect(pageContextInit, httpRequestId) {
     });
     if (origin)
         urlTarget = addUrlOrigin(urlTarget, origin);
-    assert(urlOriginalPathnameWithouBase);
     if (urlTarget === urlWithoutBase)
         return null;
     logRuntimeInfo?.(`Permanent redirect defined by your config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
     urlTarget = prependBase(urlTarget, baseServer);
     assert(urlTarget !== pageContextInit.urlOriginal);
-    const httpResponse = createHttpResponseObjectRedirect({ url: urlTarget, statusCode: 301 }, urlOriginalPathnameWithouBase);
+    const httpResponse = createHttpResponseObjectRedirect({ url: urlTarget, statusCode: 301 }, urlWithoutBase);
     const pageContextHttpResponse = { ...pageContextInit, httpResponse };
     return pageContextHttpResponse;
 }
@@ -390,7 +387,13 @@ async function handleAbortError(errAbort, pageContextsFromRewrite, pageContextIn
             ...pageContextInit,
             ...pageContextAbort
         };
-        const httpResponse = createHttpResponseObjectRedirect(pageContextAbort._urlRedirect, pageContextNominalPageInit.urlPathname);
+        const httpResponse = createHttpResponseObjectRedirect(pageContextAbort._urlRedirect, (() => {
+            const { pathname, searchOriginal } = pageContextNominalPageInit.urlParsed;
+            const urlLogical = createUrlFromComponents(null, pathname, searchOriginal, 
+            // The server-side doesn't have access to the hash
+            null);
+            return urlLogical;
+        })());
         objectAssign(pageContextReturn, { httpResponse });
         return { pageContextReturn };
     }

package/dist/esm/shared/getPageFiles/analyzePageClientSide/determineClientEntry.js

@@ -1,3 +1,4 @@
+// TODO/v1-release: remove
 export { determineClientEntry };
 export { getVikeClientEntry };
 function determineClientEntry({ pageFilesClientSide, pageFilesServerSide, isHtmlOnly, isClientRouting }) {

package/dist/esm/shared/page-configs/PageConfig.d.ts

@@ -16,7 +16,7 @@ export type { DefinedAtFile };
 export type { DefinedAtFileFullInfo };
 export type { FilePathResolved };
 export type { FilePath };
-import type { ConfigValueImported } from './serialize/PageConfigSerialized.js';
+import type { ConfigValueImported, ConfigValueSerialized } from './serialize/PageConfigSerialized.js';
 type PageConfigBase = {
     pageId: string;
     isErrorPage?: true;
@@ -30,7 +30,10 @@ type PageConfigRuntime = PageConfigBase & {
     /** All loaded config values */
     configValues: ConfigValues;
     /** Load config values that are lazily loaded such as config.Page */
-    loadConfigValuesAll: () => Promise<ConfigValueImported[]>;
+    loadConfigValuesAll: () => Promise<{
+        configValuesImported: ConfigValueImported[];
+        configValuesSerialized: Record<string, ConfigValueSerialized>;
+    }>;
 };
 /** Same as PageConfigRuntime but also contains all lazily loaded config values such as config.Page */
 type PageConfigRuntimeLoaded = PageConfigRuntime & {
@@ -50,9 +53,16 @@ type PageConfigGlobalRuntime = {
 type PageConfigGlobalBuildTime = {
     configValueSources: ConfigValueSources;
 };
-type ConfigEnv = 'client-only' | 'server-only' | 'server-and-client' | 'config-only';
+type ConfigEnv = {
+    client?: boolean;
+    server?: boolean;
+    config?: boolean;
+};
 /** For Vike internal use */
-type ConfigEnvInternal = ConfigEnv | '_routing-eager' | '_routing-lazy';
+type ConfigEnvInternal = Omit<ConfigEnv, 'client'> & {
+    client?: boolean | 'if-client-routing';
+    eager?: boolean;
+};
 type ConfigValueSource = {
     value?: unknown;
     configEnv: ConfigEnvInternal;

package/dist/esm/shared/page-configs/loadConfigValues.js

@@ -1,15 +1,24 @@
 export { loadConfigValues };
 import { objectAssign } from '../utils.js';
 import { parseConfigValuesImported } from './serialize/parseConfigValuesImported.js';
+import { parseConfigValuesSerialized } from './serialize/parseConfigValuesSerialized.js';
 async function loadConfigValues(pageConfig, isDev) {
     if ('isAllLoaded' in pageConfig &&
         // We don't need to cache in dev, since Vite already caches the virtual module
         !isDev) {
         return pageConfig;
     }
-    const configValuesImported = await pageConfig.loadConfigValuesAll();
-    const configValuesAddendum = parseConfigValuesImported(configValuesImported);
-    Object.assign(pageConfig.configValues, configValuesAddendum);
+    const configValuesLoaded = await pageConfig.loadConfigValuesAll();
+    {
+        const { configValuesImported } = configValuesLoaded;
+        const configValuesAddendum = parseConfigValuesImported(configValuesImported);
+        Object.assign(pageConfig.configValues, configValuesAddendum);
+    }
+    {
+        const { configValuesSerialized } = configValuesLoaded;
+        const configValuesAddendum = parseConfigValuesSerialized(configValuesSerialized);
+        Object.assign(pageConfig.configValues, configValuesAddendum);
+    }
     objectAssign(pageConfig, { isAllLoaded: true });
     return pageConfig;
 }

package/dist/esm/shared/page-configs/serialize/parseConfigValuesSerialized.d.ts

@@ -0,0 +1,4 @@
+export { parseConfigValuesSerialized };
+import type { ConfigValues } from '../PageConfig.js';
+import type { ConfigValueSerialized } from './PageConfigSerialized.js';
+declare function parseConfigValuesSerialized(configValuesSerialized: Record<string, ConfigValueSerialized>): ConfigValues;

package/dist/esm/shared/page-configs/serialize/parseConfigValuesSerialized.js

@@ -0,0 +1,16 @@
+export { parseConfigValuesSerialized };
+import { assert } from '../../utils.js';
+import { parse } from '@brillout/json-serializer/parse';
+function parseConfigValuesSerialized(configValuesSerialized) {
+    const configValues = {};
+    Object.entries(configValuesSerialized).forEach(([configName, configValueSeriliazed]) => {
+        const { valueSerialized, definedAt } = configValueSeriliazed;
+        assert(valueSerialized);
+        assert(!configValues[configName]);
+        configValues[configName] = {
+            value: parse(valueSerialized),
+            definedAt
+        };
+    });
+    return configValues;
+}

package/dist/esm/shared/page-configs/serialize/parsePageConfigs.js

@@ -1,24 +1,15 @@
 export { parsePageConfigs };
-import { parse } from '@brillout/json-serializer/parse';
 import { parseConfigValuesImported } from './parseConfigValuesImported.js';
-import { assert, assertUsage, isCallable } from '../../utils.js';
+import { assertUsage, isCallable } from '../../utils.js';
 import { getConfigDefinedAtString } from '../helpers.js';
+import { parseConfigValuesSerialized } from './parseConfigValuesSerialized.js';
 function parsePageConfigs(pageConfigsSerialized, pageConfigGlobalSerialized) {
     const pageConfigs = pageConfigsSerialized.map((pageConfigSerialized) => {
         const configValues = {};
         {
             const { configValuesSerialized } = pageConfigSerialized;
-            Object.entries(configValuesSerialized).forEach(([configName, configValueSeriliazed]) => {
-                {
-                    const { valueSerialized, definedAt } = configValueSeriliazed;
-                    assert(valueSerialized);
-                    assert(!configValues[configName]);
-                    configValues[configName] = {
-                        value: parse(valueSerialized),
-                        definedAt
-                    };
-                }
-            });
+            const configValuesAddendum = parseConfigValuesSerialized(configValuesSerialized);
+            Object.assign(configValues, configValuesAddendum);
         }
         {
             const { configValuesImported } = pageConfigSerialized;

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

@@ -0,0 +1,4 @@
+export { assertKeys };
+declare function assertKeys<Keys extends readonly string[]>(obj: Record<string, unknown>, keysExpected: Keys, errPrefix: string): asserts obj is {
+    [key in Keys[number]]?: unknown;
+};

package/dist/esm/utils/assertKeys.js

@@ -0,0 +1,22 @@
+export { assertKeys };
+import pc from '@brillout/picocolors';
+import { assertUsage } from './assert.js';
+import { joinEnglish } from './joinEnglish.js';
+function assertKeys(obj, keysExpected, errPrefix) {
+    const keysUnknown = [];
+    const keys = Object.keys(obj);
+    for (const key of keys) {
+        if (!keysExpected.includes(key)) {
+            keysUnknown.push(key);
+        }
+    }
+    if (keysUnknown.length !== 0) {
+        assertUsage(false, [
+            errPrefix,
+            `unknown key${keysUnknown.length === 1 ? '' : 's'}`,
+            joinEnglish(keysUnknown, 'and', pc.cyan) + '.',
+            'Only following keys are allowed:',
+            joinEnglish(keysExpected, 'and', pc.cyan) + '.'
+        ].join(' '));
+    }
+}

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

@@ -1,2 +1,2 @@
 export { joinEnglish };
-declare function joinEnglish(arr: string[], conjunction: 'or' | 'and'): string;
+declare function joinEnglish(arr: string[] | readonly string[], conjunction: 'or' | 'and', colorizer?: (s: string) => string): string;

package/dist/esm/utils/joinEnglish.js

@@ -1,11 +1,11 @@
 export { joinEnglish };
 import { assert } from './assert.js';
 // https://stackoverflow.com/questions/53879088/join-an-array-by-commas-and-and/53879103#53879103
-function joinEnglish(arr, conjunction) {
+function joinEnglish(arr, conjunction, colorizer = (s) => s) {
     assert(arr.length > 0);
     if (arr.length === 1)
-        return arr[0];
+        return colorizer(arr[0]);
     const firsts = arr.slice(0, arr.length - 1);
     const last = arr[arr.length - 1];
-    return firsts.join(', ') + ` ${conjunction} ` + last;
+    return firsts.map(colorizer).join(', ') + ` ${conjunction} ` + colorizer(last);
 }

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

@@ -8,7 +8,7 @@ export { addUrlOrigin };
 declare function prependBase(url: string, baseServer: string): string;
 declare function removeBaseServer(url: string, baseServer: string): string;
 declare function isBaseAssets(base: string): boolean;
-declare function normalizeUrlPathname(urlOriginal: string, trailingSlash: boolean): string | null;
+declare function normalizeUrlPathname(urlOriginal: string, trailingSlash: boolean, baseServer: string): string | null;
 declare function modifyUrlPathname(url: string, modifier: (urlPathname: string) => string | null): string;
 declare function removeUrlOrigin(url: string): {
     urlModified: string;

package/dist/esm/utils/parseUrl-extras.js

@@ -53,15 +53,20 @@ function normalizeBaseServer(baseServer) {
 function isBaseAssets(base) {
     return base.startsWith('/') || base.startsWith('http://') || base.startsWith('https://');
 }
-function normalizeUrlPathname(urlOriginal, trailingSlash) {
+function normalizeUrlPathname(urlOriginal, trailingSlash, baseServer) {
     const urlNormalized = modifyUrlPathname(urlOriginal, (urlPathname) => {
         assert(urlPathname.startsWith('/'));
-        let urlPathnameNormalized = '/' + urlPathname.split('/').filter(Boolean).join('/');
-        if (urlPathnameNormalized !== '/') {
-            assert(!urlPathnameNormalized.endsWith('/'));
-            if (trailingSlash) {
-                urlPathnameNormalized = urlPathnameNormalized + '/';
-            }
+        let urlPathnameNormalized = normalize(urlPathname);
+        if (urlPathnameNormalized === '/') {
+            return urlPathnameNormalized;
+        }
+        // If the Base URL has a trailing slash, then Vite (as of vite@5.0.0-beta.19) expects the root URL to also have a trailing slash, see https://github.com/vikejs/vike/issues/1258#issuecomment-1812226260
+        if (baseServer.endsWith('/') && baseServer !== '/' && normalize(baseServer) === urlPathnameNormalized) {
+            trailingSlash = true;
+        }
+        assert(!urlPathnameNormalized.endsWith('/'));
+        if (trailingSlash) {
+            urlPathnameNormalized = urlPathnameNormalized + '/';
         }
         return urlPathnameNormalized;
     });
@@ -69,6 +74,10 @@ function normalizeUrlPathname(urlOriginal, trailingSlash) {
         return null;
     return urlNormalized;
 }
+function normalize(urlPathname) {
+    assert(urlPathname.startsWith('/'));
+    return '/' + urlPathname.split('/').filter(Boolean).join('/');
+}
 function modifyUrlPathname(url, modifier) {
     const { origin, pathnameOriginal, searchOriginal, hashOriginal } = parseUrl(url, '/');
     const pathnameModified = modifier(pathnameOriginal);

package/dist/esm/utils/parseUrl.js

@@ -54,7 +54,7 @@ function parseUrl(url, baseServer) {
         searchAll[key] = [...(searchAll.hasOwnProperty(key) ? searchAll[key] : []), val];
     });
     // Origin + pathname
-    const { origin, pathname: pathnameResolved } = parsePathname(urlWithoutHashNorSearch, baseServer);
+    const { origin, pathname: pathnameResolved } = getPathname(urlWithoutHashNorSearch, baseServer);
     assert(origin === null || origin === decodeSafe(origin)); // AFAICT decoding the origin is useless
     assert(pathnameResolved.startsWith('/'));
     assert(origin === null || url.startsWith(origin));
@@ -89,35 +89,43 @@ function decodeSafe(urlComponent) {
     return urlComponent;
 }
 function decodePathname(urlPathname) {
+    urlPathname = urlPathname.replace(/\s+$/, '');
     urlPathname = urlPathname
         .split('/')
         .map((dir) => decodeSafe(dir).split('/').join('%2F'))
         .join('/');
-    urlPathname = urlPathname.replace(/\s/g, '');
     return urlPathname;
 }
-function parsePathname(urlWithoutHashNorSearch, baseServer) {
+function getPathname(url, baseServer) {
+    // Search and hash already extracted
+    assert(!url.includes('?') && !url.includes('#'));
+    // url has origin
     {
-        const { origin, pathname } = parseOrigin(urlWithoutHashNorSearch);
+        const { origin, pathname } = parseOrigin(url);
         if (origin) {
             return { origin, pathname };
         }
-        assert(pathname === urlWithoutHashNorSearch);
+        assert(pathname === url);
     }
-    if (urlWithoutHashNorSearch.startsWith('/')) {
-        return { origin: null, pathname: urlWithoutHashNorSearch };
+    // url doesn't have origin
+    if (url.startsWith('/')) {
+        return { origin: null, pathname: url };
     }
     else {
-        // In the browser, this is the Base URL of the current URL
+        // url is a relative path
+        // 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
-        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);
-        return parsed;
+        const baseURI = typeof window !== 'undefined' ? window?.document?.baseURI : undefined;
+        let base;
+        if (baseURI) {
+            const baseURIPathaname = parseOrigin(baseURI.split('?')[0]).pathname;
+            base = baseURIPathaname;
+        }
+        else {
+            base = baseServer;
+        }
+        const pathname = resolveUrlPathnameRelative(url, base);
+        return { origin: null, pathname };
     }
 }
 function parseOrigin(url) {

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

@@ -1,11 +1,13 @@
 export { projectInfo };
 export type { ProjectTag };
+export { PROJECT_VERSION };
+declare const PROJECT_VERSION: "0.4.147-commit-2fa53b2";
 type PackageName = typeof projectInfo.npmPackageName;
 type ProjectVersion = typeof projectInfo.projectVersion;
 type ProjectTag = `[${PackageName}]` | `[${PackageName}@${ProjectVersion}]`;
 declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.146";
+    projectVersion: "0.4.147-commit-2fa53b2";
     npmPackageName: "vike";
     githubRepository: "https://github.com/vikejs/vike";
 };

package/dist/esm/utils/projectInfo.js

@@ -1,6 +1,7 @@
 export { projectInfo };
+export { PROJECT_VERSION };
 import { onProjectInfo } from './assertSingleInstance.js';
-const PROJECT_VERSION = '0.4.146';
+const PROJECT_VERSION = '0.4.147-commit-2fa53b2';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.146",
+  "version": "0.4.147-commit-2fa53b2",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",
@@ -14,7 +14,7 @@
   "dependencies": {
     "@brillout/import": "0.2.3",
     "@brillout/json-serializer": "^0.5.8",
-    "@brillout/picocolors": "^1.0.9",
+    "@brillout/picocolors": "^1.0.10",
     "@brillout/require-shim": "^0.1.2",
     "@brillout/vite-plugin-import-build": "^0.2.20",
     "acorn": "^8.8.2",
@@ -162,7 +162,7 @@
     "vike": "./node/cli/bin-entry.js"
   },
   "devDependencies": {
-    "@brillout/release-me": "^0.1.8",
+    "@brillout/release-me": "^0.1.9",
     "@types/estree": "^1.0.0",
     "@types/jest": "^27.4.1",
     "@types/node": "^20.1.0",

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/helpers.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isConfigSet = exports.getConfigEnv = void 0;
-const utils_js_1 = require("../../../utils.js");
-(0, utils_js_1.assertIsNotProductionRuntime)();
-function getConfigEnv(configValueSources, configName) {
-    const configValueSource = getConfigValueSource(configValueSources, configName);
-    if (!configValueSource)
-        return null;
-    return configValueSource.configEnv;
-}
-exports.getConfigEnv = getConfigEnv;
-function isConfigSet(configValueSources, configName) {
-    const configValueSource = getConfigValueSource(configValueSources, configName);
-    // Enable users to suppress global config values by overriding the config's value to null
-    if (configValueSource?.value === null)
-        return false;
-    return !!configValueSource;
-}
-exports.isConfigSet = isConfigSet;
-function getConfigValueSource(configValueSources, configName) {
-    const sources = configValueSources[configName];
-    if (!sources)
-        return null;
-    const configValueSource = sources[0];
-    (0, utils_js_1.assert)(configValueSource);
-    return configValueSource;
-}

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

@@ -1,5 +0,0 @@
-export { getConfigEnv };
-export { isConfigSet };
-import type { ConfigEnvInternal, ConfigValueSources } from '../../../../../shared/page-configs/PageConfig.js';
-declare function getConfigEnv(configValueSources: ConfigValueSources, configName: string): null | ConfigEnvInternal;
-declare function isConfigSet(configValueSources: ConfigValueSources, configName: string): boolean;

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

@@ -1,25 +0,0 @@
-export { getConfigEnv };
-export { isConfigSet };
-import { assert, assertIsNotProductionRuntime } from '../../../utils.js';
-assertIsNotProductionRuntime();
-function getConfigEnv(configValueSources, configName) {
-    const configValueSource = getConfigValueSource(configValueSources, configName);
-    if (!configValueSource)
-        return null;
-    return configValueSource.configEnv;
-}
-function isConfigSet(configValueSources, configName) {
-    const configValueSource = getConfigValueSource(configValueSources, configName);
-    // Enable users to suppress global config values by overriding the config's value to null
-    if (configValueSource?.value === null)
-        return false;
-    return !!configValueSource;
-}
-function getConfigValueSource(configValueSources, configName) {
-    const sources = configValueSources[configName];
-    if (!sources)
-        return null;
-    const configValueSource = sources[0];
-    assert(configValueSource);
-    return configValueSource;
-}

package/dist/esm/node/plugin/shared/getConfigValueSourcesRelevant.d.ts

@@ -1,5 +0,0 @@
-export { getConfigValueSourcesRelevant };
-import type { ConfigValueSource, PageConfigBuildTime } from '../../../shared/page-configs/PageConfig.js';
-declare function getConfigValueSourcesRelevant(pageConfig: PageConfigBuildTime): (ConfigValueSource & {
-    configName: string;
-})[];