vike 0.4.147 → 0.4.148-commit-7596dcd

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

@@ -3,6 +3,8 @@ export type { ConfigBuiltIn };
 export type { ConfigNameBuiltIn };
 export type { ConfigMeta };
 export type { HookName };
+export type { HookNamePage };
+export type { HookNameGlobal };
 export type { GuardAsync };
 export type { GuardSync };
 export type { OnBeforePrerenderStartAsync };
@@ -30,9 +32,13 @@ import type { ConfigDefinition } from '../../node/plugin/plugins/importUserCode/
 import type { DocumentHtml } from '../../node/runtime/html/renderHtml.js';
 import type { ConfigVikeUserProvided } from '../ConfigVike.js';
 import type { Vike, VikePackages } from '../VikeNamespace.js';
+import type { HooksTimeoutProvidedByUser } from '../hooks/getHook.js';
 import type { PageContextClient, PageContextServer } from '../types.js';
-type HookName = 'onHydrationEnd' | 'onBeforePrerender' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onBeforeRoute' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onPrerenderStart' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'render';
-type ConfigNameBuiltIn = Exclude<keyof Config, keyof ConfigVikeUserProvided | 'onBeforeRoute' | 'onPrerenderStart'> | 'prerender' | 'isClientSideRenderable' | 'onBeforeRenderEnv';
+type HookName = HookNamePage | HookNameGlobal | HookNameOldDesign;
+type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard';
+type HookNameGlobal = 'onBeforePrerender' | 'onBeforeRoute' | 'onPrerenderStart';
+type HookNameOldDesign = 'render' | 'prerender';
+type ConfigNameBuiltIn = Exclude<keyof Config, keyof ConfigVikeUserProvided | 'onBeforeRoute' | 'onPrerenderStart'> | 'prerender' | 'isClientSideRenderable' | 'onBeforeRenderEnv' | 'hooksTimeout';
 type Config = ConfigBuiltIn & Vike.Config & (VikePackages.ConfigVikeReact | VikePackages.ConfigVikeVue | VikePackages.ConfigVikeSolid | VikePackages.ConfigVikeSvelte);
 /** Protect page(s), e.g. forbid unauthorized access.
  *
@@ -102,32 +108,32 @@ type OnBeforeRouteSync = (pageContext: PageContextServer) => {
 };
 /** Hook called after the page is hydrated.
  *
- * https://vike.dev/clientRouting
+ * https://vike.dev/onHydrationEnd
  */
 type OnHydrationEndAsync = (pageContext: PageContextClient) => Promise<void>;
 /** Hook called after the page is hydrated.
  *
- * https://vike.dev/clientRouting
+ * https://vike.dev/onHydrationEnd
  */
 type OnHydrationEndSync = (pageContext: PageContextClient) => void;
 /** Hook called after the user navigates to a new page.
  *
- * https://vike.dev/clientRouting
+ * https://vike.dev/onPageTransitionEnd
  */
 type OnPageTransitionEndAsync = (pageContext: PageContextClient) => Promise<void>;
 /** Hook called after the user navigates to a new page.
  *
- * https://vike.dev/clientRouting
+ * https://vike.dev/onPageTransitionEnd
  */
 type OnPageTransitionEndSync = (pageContext: PageContextClient) => void;
 /** Hook called before the user navigates to a new page.
  *
- * https://vike.dev/clientRouting
+ * https://vike.dev/onPageTransitionStart
  */
 type OnPageTransitionStartAsync = (pageContext: PageContextClient) => Promise<void>;
 /** Hook called before the user navigates to a new page.
  *
- * https://vike.dev/clientRouting
+ * https://vike.dev/onPageTransitionStart
  */
 type OnPageTransitionStartSync = (pageContext: PageContextClient) => void;
 /** Page Hook called when pre-rendering starts.
@@ -275,22 +281,22 @@ type ConfigBuiltIn = {
     onBeforeRoute?: OnBeforeRouteAsync | OnBeforeRouteSync | ImportString;
     /** Hook called after the page is hydrated.
      *
-     * https://vike.dev/clientRouting
+     * https://vike.dev/onHydrationEnd
      */
     onHydrationEnd?: OnHydrationEndAsync | OnHydrationEndSync | ImportString;
     /** Hook called before the user navigates to a new page.
      *
-     * https://vike.dev/clientRouting
+     * https://vike.dev/onPageTransitionStart
      */
     onPageTransitionStart?: OnPageTransitionStartAsync | OnPageTransitionStartSync | ImportString;
     /** Hook called after the user navigates to a new page.
      *
-     * https://vike.dev/clientRouting
+     * https://vike.dev/onPageTransitionEnd
      */
     onPageTransitionEnd?: OnPageTransitionEndAsync | OnPageTransitionEndSync | ImportString;
     /** Whether the UI framework (React/Vue/Solid/...) allows the page's hydration to be aborted.
      *
-     * https://vike.dev/clientRouting
+     * https://vike.dev/hydrationCanBeAborted
      */
     hydrationCanBeAborted?: boolean | ImportString;
     /** Additional client code.
@@ -310,9 +316,11 @@ type ConfigBuiltIn = {
     meta?: ConfigMeta | ImportString;
     /** Prefetch links.
      *
-     * https://vike.dev/clientRouting#link-prefetching
+     * https://vike.dev/prefetchStaticAssets
      */
     prefetchStaticAssets?: PrefetchStaticAssets | ImportString;
+    /** Modify the tiemouts of hooks. */
+    hooksTimeout?: HooksTimeoutProvidedByUser;
 };
 type ConfigMeta = Record<string, ConfigDefinition>;
 type ImportString = `import:${string}`;

package/dist/esm/shared/page-configs/helpers/getConfigDefinedAtString.d.ts

@@ -1,7 +1,7 @@
 export { getConfigDefinedAtString };
 export { getDefinedAtString };
 import type { DefinedAt } from '../PageConfig.js';
-declare function getConfigDefinedAtString<ConfigName extends string, SentenceBegin extends 'Config' | 'config' | 'Hook'>(sentenceBegin: SentenceBegin, configName: ConfigName, { definedAt }: {
+declare function getConfigDefinedAtString<ConfigName extends string, SentenceBegin extends 'Config' | 'config'>(sentenceBegin: SentenceBegin, configName: ConfigName, { definedAt }: {
     definedAt: DefinedAt;
 }): `${SentenceBegin} ${ConfigName}${string} defined ${'internally' | `at ${string}`}`;
 declare function getDefinedAtString(definedAt: DefinedAt, configName: string): string;

package/dist/esm/shared/page-configs/helpers/getConfigDefinedAtString.js

@@ -6,7 +6,7 @@ import { getExportPath } from '../getExportPath.js';
 function getConfigDefinedAtString(sentenceBegin, configName, { definedAt }) {
     const definedAtString = getDefinedAtString(definedAt, configName);
     const definedAtStr = definedAtString === 'internally' ? definedAtString : `at ${definedAtString}`;
-    let configNameStr = `${configName}${sentenceBegin === 'Hook' ? '()' : ''}`;
+    let configNameStr = `${configName}${ /*sentenceBegin === 'Hook' ? '()' :*/''}`;
     const configDefinedAt = `${sentenceBegin} ${pc.cyan(configNameStr)} defined ${definedAtStr}`;
     return configDefinedAt;
 }

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

@@ -1,5 +1,5 @@
 export { executeGuardHook };
-import { getHook } from '../hooks/getHook.js';
+import { getHook, getHookTimeoutDefault } from '../hooks/getHook.js';
 import { assert, assertUsage, executeHook, isCallable } from './utils.js';
 async function executeGuardHook(pageContext, prepareForUserConsumption) {
     let hook;
@@ -19,7 +19,7 @@ async function executeGuardHook(pageContext, prepareForUserConsumption) {
     const res = prepareForUserConsumption(pageContext);
     if (res)
         pageContextForUserConsumption = res;
-    const hookResult = await executeHook(() => guard(pageContextForUserConsumption), 'guard', hook.hookFilePath);
+    const hookResult = await executeHook(() => guard(pageContextForUserConsumption), hook);
     assertUsage(hookResult === undefined, `The guard() hook of ${hook.hookFilePath} returns a value, but guard() doesn't accept any return value`);
 }
 function findPageGuard(pageId, pageFilesAll) {
@@ -32,6 +32,7 @@ function findPageGuard(pageId, pageFilesAll) {
     if (!hookFn)
         return null;
     const hookFilePath = filePath;
+    const hookTimeout = getHookTimeoutDefault('guard');
     assertUsage(isCallable(hookFn), `guard() defined by ${hookFilePath} should be a function`);
-    return { hookFn, hookName: 'guard', hookFilePath };
+    return { hookFn, hookName: 'guard', hookFilePath, hookTimeout };
 }

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

@@ -1,12 +1,5 @@
-import type { PageContextForRoute, PageContextFromRoute } from './index.js';
 export { executeOnBeforeRouteHook };
-export type { OnBeforeRouteHook };
-type OnBeforeRouteHook = {
-    hookFilePath: string;
-    onBeforeRoute: (pageContext: {
-        urlOriginal: string;
-    } & Record<string, unknown>) => unknown;
-};
+import type { PageContextForRoute, PageContextFromRoute } from './index.js';
 declare function executeOnBeforeRouteHook(pageContext: PageContextForRoute): Promise<null | ({
     _routingProvidedByOnBeforeRouteHook: true;
 } & PageContextFromRoute) | {

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

@@ -1,13 +1,13 @@
+export { executeOnBeforeRouteHook };
 import { assertPageContextProvidedByUser } from '../assertPageContextProvidedByUser.js';
-import { assertUsage, hasProp, isObjectWithKeys, objectAssign, assertWarning, assertUsageUrl, joinEnglish, assert } from './utils.js';
+import { assertUsage, hasProp, isObjectWithKeys, objectAssign, assertWarning, assertUsageUrl, joinEnglish, assert, executeHook } from './utils.js';
 import { assertRouteParams, assertSyncRouting } from './resolveRouteFunction.js';
 import pc from '@brillout/picocolors';
-export { executeOnBeforeRouteHook };
 async function executeOnBeforeRouteHook(pageContext) {
     const pageContextFromOnBeforeRouteHook = {};
     if (!pageContext._onBeforeRouteHook)
         return null;
-    const pageContextFromHook = await executeHook(pageContext._onBeforeRouteHook, pageContext);
+    const pageContextFromHook = await getPageContextFromHook(pageContext._onBeforeRouteHook, pageContext);
     if (pageContextFromHook) {
         objectAssign(pageContextFromOnBeforeRouteHook, pageContextFromHook);
         if (hasProp(pageContextFromOnBeforeRouteHook, '_pageId', 'string') ||
@@ -31,11 +31,11 @@ async function executeOnBeforeRouteHook(pageContext) {
     });
     return pageContextFromOnBeforeRouteHook;
 }
-async function executeHook(onBeforeRouteHook, pageContext) {
-    let hookReturn = onBeforeRouteHook.onBeforeRoute(pageContext);
+async function getPageContextFromHook(onBeforeRouteHook, pageContext) {
+    let hookReturn = onBeforeRouteHook.hookFn(pageContext);
     assertSyncRouting(hookReturn, `The onBeforeRoute() hook ${onBeforeRouteHook.hookFilePath}`);
     // TODO/v1-release: make executeOnBeforeRouteHook() and route() sync
-    hookReturn = await hookReturn;
+    hookReturn = await executeHook(() => hookReturn, onBeforeRouteHook);
     const errPrefix = `The onBeforeRoute() hook defined by ${onBeforeRouteHook.hookFilePath}`;
     assertUsage(hookReturn === null ||
         hookReturn === undefined ||

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

@@ -5,16 +5,16 @@ export type { PageRoutes };
 export type { RouteMatches };
 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 { PageConfigRuntime, PageConfigGlobalRuntime } from '../page-configs/PageConfig.js';
+import type { Hook } from '../hooks/getHook.js';
 type PageContextForRoute = PageContextUrlComputedPropsInternal & {
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
     _allPageIds: string[];
     _pageConfigGlobal: PageConfigGlobalRuntime;
     _pageRoutes: PageRoutes;
-    _onBeforeRouteHook: OnBeforeRouteHook | null;
+    _onBeforeRouteHook: Hook | null;
 } & PageContextUrlSources;
 type PageContextFromRoute = {
     _pageId: string | null;

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

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

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

@@ -3,8 +3,9 @@ import { isErrorPageId } from '../error-page.js';
 import { assert, assertUsage, hasProp, slice } from './utils.js';
 import { deduceRouteStringFromFilesystemPath } from './deduceRouteStringFromFilesystemPath.js';
 import { isCallable } from '../utils.js';
-import { getConfigDefinedAtString, getConfigValue, getDefinedAtString, getHookFilePathToShowToUser } from '../page-configs/helpers.js';
+import { getConfigValue, getDefinedAtString } from '../page-configs/helpers.js';
 import { warnDeprecatedAllowKey } from './resolveRouteFunction.js';
+import { getHookFromPageConfigGlobal, getHookTimeoutDefault } from '../hooks/getHook.js';
 async function loadPageRoutes(
 // Remove all arguments and use GlobalContext instead?
 pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds) {
@@ -136,20 +137,8 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
 function getGlobalHooks(pageFilesAll, pageConfigs, pageConfigGlobal) {
     // V1 Design
     if (pageConfigs.length > 0) {
-        const hookName = 'onBeforeRoute';
-        if (pageConfigGlobal.configValues[hookName]?.value) {
-            const configValue = pageConfigGlobal.configValues[hookName];
-            const { value: hookFn } = configValue;
-            const hookFilePath = getHookFilePathToShowToUser(configValue);
-            const hookDefinedAt = getConfigDefinedAtString('Hook', hookName, configValue);
-            assertUsage(isCallable(hookFn), `${hookDefinedAt} should be a function.`);
-            const onBeforeRouteHook = {
-                hookFilePath: hookFilePath,
-                onBeforeRoute: hookFn
-            };
-            return { onBeforeRouteHook, filesystemRoots: null };
-        }
-        return { onBeforeRouteHook: null, filesystemRoots: null };
+        const hook = getHookFromPageConfigGlobal(pageConfigGlobal, 'onBeforeRoute');
+        return { onBeforeRouteHook: hook, filesystemRoots: null };
     }
     // Old design
     // TODO/v1-release: remove
@@ -162,7 +151,13 @@ function getGlobalHooks(pageFilesAll, pageConfigs, pageConfigGlobal) {
         if ('onBeforeRoute' in fileExports) {
             assertUsage(hasProp(fileExports, 'onBeforeRoute', 'function'), `\`export { onBeforeRoute }\` of ${filePath} should be a function.`);
             const { onBeforeRoute } = fileExports;
-            onBeforeRouteHook = { hookFilePath: `${filePath} > \`export { onBeforeRoute }\``, onBeforeRoute };
+            const hookName = 'onBeforeRoute';
+            onBeforeRouteHook = {
+                hookFilePath: filePath,
+                hookFn: onBeforeRoute,
+                hookName,
+                hookTimeout: getHookTimeoutDefault(hookName)
+            };
         }
         if ('filesystemRoutingRoot' in fileExports) {
             assertUsage(hasProp(fileExports, 'filesystemRoutingRoot', 'string'), `\`export { filesystemRoutingRoot }\` of ${filePath} should be a string.`);

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

@@ -2,6 +2,7 @@ export { resolveRedirects };
 // For ./resolveRedirects.spec.ts
 export { resolveRouteStringRedirect };
 import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
+import { isUriWithProtocol } from '../../utils/parseUrl-extras.js';
 import { assert, assertUsage } from '../utils.js';
 import { assertRouteString, resolveRouteString } from './resolveRouteString.js';
 import pc from '@brillout/picocolors';
@@ -19,9 +20,9 @@ function resolveRedirects(redirects, urlPathname) {
 function resolveRouteStringRedirect(urlSource, urlTarget, urlPathname) {
     assertRouteString(urlSource, `${configSrc} Invalid`);
     assertUsage(urlTarget.startsWith('/') ||
-        urlTarget.startsWith('http://') ||
-        urlTarget.startsWith('https://') ||
-        urlTarget === '*', `${configSrc} Invalid redirection target URL ${pc.cyan(urlTarget)}: the target URL should start with ${pc.cyan('/')}, ${pc.cyan('http://')}, ${pc.cyan('https://')}, or be ${pc.cyan('*')}`);
+        // Is allowing any protocol a safety issue? https://github.com/vikejs/vike/pull/1292#issuecomment-1828043917
+        isUriWithProtocol(urlTarget) ||
+        urlTarget === '*', `${configSrc} Invalid redirection target URL ${pc.cyan(urlTarget)}: the target URL should start with ${pc.cyan('/')}, a valid protocol (${pc.cyan('https:')}, ${pc.cyan('http:')}, ${pc.cyan('ipfs:')}, ${pc.cyan('magnet:')}, ...), or be ${pc.cyan('*')}`);
     assertParams(urlSource, urlTarget);
     const match = resolveRouteString(urlSource, urlPathname);
     if (!match)
@@ -33,10 +34,12 @@ function resolveRouteStringRedirect(urlSource, urlTarget, urlPathname) {
         }
         urlResolved = urlResolved.replaceAll(key, val);
     });
-    assert(!urlResolved.includes('@'));
+    if (!urlResolved.startsWith('mailto:')) {
+        assertUsage(!urlResolved.includes('@'), 'URL should not contain "@" unless it is a mailto link.');
+    }
     if (urlResolved === urlPathname)
         return null;
-    assert(urlTarget.startsWith('/') || urlTarget.startsWith('http'));
+    assert(urlResolved.startsWith('/') || isUriWithProtocol(urlResolved));
     return urlResolved;
 }
 function assertParams(urlSource, urlTarget) {

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

@@ -5,6 +5,7 @@ export { removeBaseServer };
 export { modifyUrlPathname };
 export { removeUrlOrigin };
 export { addUrlOrigin };
+export { isUriWithProtocol };
 declare function prependBase(url: string, baseServer: string): string;
 declare function removeBaseServer(url: string, baseServer: string): string;
 declare function isBaseAssets(base: string): boolean;
@@ -15,3 +16,4 @@ declare function removeUrlOrigin(url: string): {
     origin: string | null;
 };
 declare function addUrlOrigin(url: string, origin: string | null): string;
+declare function isUriWithProtocol(uri: string): boolean;

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

@@ -5,6 +5,7 @@ export { removeBaseServer };
 export { modifyUrlPathname };
 export { removeUrlOrigin };
 export { addUrlOrigin };
+export { isUriWithProtocol };
 import { assertUrlComponents, createUrlFromComponents, isBaseServer, parseUrl } from './parseUrl.js';
 import { assert } from './assert.js';
 import { slice } from './slice.js';
@@ -100,3 +101,7 @@ function addUrlOrigin(url, origin) {
     const urlModified = createUrlFromComponents(origin, pathnameOriginal, searchOriginal, hashOriginal);
     return urlModified;
 }
+function isUriWithProtocol(uri) {
+    // https://en.wikipedia.org/wiki/List_of_URI_schemes
+    return /^[a-z0-9][a-z0-9\.\+\-]*:/i.test(uri);
+}

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,13 +1,13 @@
 export { projectInfo };
 export type { ProjectTag };
 export { PROJECT_VERSION };
-declare const PROJECT_VERSION: "0.4.147";
+declare const PROJECT_VERSION: "0.4.148-commit-7596dcd";
 type PackageName = typeof projectInfo.npmPackageName;
 type ProjectVersion = typeof projectInfo.projectVersion;
 type ProjectTag = `[${PackageName}]` | `[${PackageName}@${ProjectVersion}]`;
 declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.147";
+    projectVersion: "0.4.148-commit-7596dcd";
     npmPackageName: "vike";
     githubRepository: "https://github.com/vikejs/vike";
 };

package/dist/esm/utils/projectInfo.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.147",
+  "version": "0.4.148-commit-7596dcd",
   "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",