vike 0.4.228 → 0.4.229-commit-a19745d

package/dist/cjs/utils/path.js

@@ -44,6 +44,16 @@ function assertPosixPath(path) {
     (0, assert_js_1.assert)(path);
     (0, assert_js_1.assert)(!path.includes('\\'), errMsg(path));
 }
-function pathIsRelative(importPath) {
-    return importPath.startsWith('./') || importPath.startsWith('../');
+// See also `import { isImportPathRelative } from './isImportPath.js'`
+function pathIsRelative(path) {
+    assertPosixPath(path);
+    if (path.startsWith('./') || path.startsWith('../')) {
+        return true;
+    }
+    else {
+        /* Not true if `path` starts with a hidden directory  (i.e. a directory with a name that starts with `.`)
+        assert(!path.startsWith('.'))
+        */
+        return false;
+    }
 }

package/dist/cjs/utils/requireResolve.js

@@ -3,10 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.requireResolve = requireResolve;
 exports.requireResolveOptional = requireResolveOptional;
-exports.requireResolveNonUserFile = requireResolveNonUserFile;
-exports.requireResolveOptionalNonUserFile = requireResolveOptionalNonUserFile;
+exports.requireResolveOptionalDir = requireResolveOptionalDir;
+exports.requireResolveNpmPackage = requireResolveNpmPackage;
+exports.requireResolveVikeDistFile = requireResolveVikeDistFile;
+exports.getVikeNodeModulesRoot = getVikeNodeModulesRoot;
 const assert_js_1 = require("./assert.js");
 const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
 const assertSetup_js_1 = require("./assertSetup.js");
@@ -14,68 +15,132 @@ const path_js_1 = require("./path.js");
 const isScriptFile_js_1 = require("./isScriptFile.js");
 const node_module_1 = require("node:module");
 const node_path_1 = __importDefault(require("node:path"));
+const parseNpmPackage_js_1 = require("./parseNpmPackage.js");
+const isNullish_js_1 = require("./isNullish.js");
+const debug_js_1 = require("./debug.js");
 // @ts-ignore `file:///${__filename.split('\\').join('/')}` is shimmed at dist/cjs by dist-cjs-fixup.js.
 const importMetaUrl = `file:///${__filename.split('\\').join('/')}`;
-const require_ = (0, node_module_1.createRequire)(importMetaUrl);
+(0, path_js_1.assertPosixPath)(importMetaUrl);
 (0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
 (0, assertSetup_js_1.assertIsNotProductionRuntime)();
-function requireResolve_(importPath, cwd, options) {
-    (0, path_js_1.assertPosixPath)(cwd);
+const debug = (0, debug_js_1.createDebugger)('vike:resolve');
+// - We still can't use import.meta.resolve() as of 23.1.0 (November 2024) because `parent` argument requires an experimental flag.
+//   - https://stackoverflow.com/questions/54977743/do-require-resolve-for-es-modules#comment139581675_62272600
+// - Passing context to createRequire(context) isn't equivalent to passing it to the `paths` argument of require.resolve()
+//   - https://github.com/brillout/require-test
+//   - In practice, I guess it doesn't make a difference? It just seems to be small Node.js weirdness.
+// - The argument createRequire(argument) seems to be overriden by the `paths` argument require.resolve()
+//   - For example, passing an empty array to `paths` kills the argument passed to `createRequire()`
+//   - Thus, when `paths` is defined, then the context needs to be passed to both createRequire() as well as the `paths` argument of require.resolve()
+function requireResolve_(importPath, importerFilePath, { userRootDir, doNotHandleFileExtension } = {}) {
     (0, path_js_1.assertPosixPath)(importPath);
-    cwd = resolveCwd(cwd);
-    let clean = () => { };
-    if (!options?.doNotHandleFileExtension) {
-        clean = addFileExtensionsToRequireResolve();
-        importPath = removeFileExtention(importPath);
+    const contexts = importerFilePath
+        ? [importerFilePath]
+        : [userRootDir ? getFakeImporterFile(userRootDir) : importMetaUrl];
+    addExtraContextForNpmPackageImport(contexts, { importPath, userRootDir });
+    let importPathResolvedFilePath;
+    let failure;
+    for (let context of contexts) {
+        (0, path_js_1.assertPosixPath)(context);
+        context = ensureFilePrefix(context);
+        const require_ = (0, node_module_1.createRequire)(context);
+        if (!doNotHandleFileExtension) {
+            addFileExtensionsToRequireResolve(require_);
+            importPath = removeFileExtention(importPath);
+        }
+        try {
+            importPathResolvedFilePath = require_.resolve(importPath);
+        }
+        catch (err) {
+            if (debug.isActivated) {
+                debug('err', err);
+                debug('importPath', importPath);
+                debug('context', context);
+            }
+            failure ?? (failure = { err });
+        }
+        if (importPathResolvedFilePath)
+            break;
     }
-    let importedFile;
-    try {
-        // We still can't use import.meta.resolve() as of 23.1.0 (November 2024) because `parent` argument requires an experimental flag.
-        // - https://stackoverflow.com/questions/54977743/do-require-resolve-for-es-modules#comment139581675_62272600
-        importedFile = require_.resolve(importPath, { paths: [cwd] });
+    if (!importPathResolvedFilePath) {
+        (0, assert_js_1.assert)(failure);
+        if (debug.isActivated) {
+            debug('FAILURE');
+            debug('importPath', importPath);
+            debug('importerFilePath', importerFilePath);
+            debug('userRootDir', userRootDir);
+            debug('doNotHandleFileExtension', doNotHandleFileExtension);
+            debug('importMetaUrl', importMetaUrl);
+            debug('contexts', contexts);
+        }
+        return { importPathResolvedFilePath: undefined, err: failure.err, hasFailed: true };
     }
-    catch (err) {
-        clean();
-        return { importedFile: undefined, err, hasFailed: true };
+    else {
+        if (failure && debug.isActivated) {
+            debug('SUCCESS');
+            debug('importPath', importPath);
+            debug('contexts', contexts);
+        }
+        (0, assert_js_1.assert)(importPathResolvedFilePath);
+        importPathResolvedFilePath = (0, path_js_1.toPosixPath)(importPathResolvedFilePath);
+        return { importPathResolvedFilePath, err: undefined, hasFailed: false };
     }
-    clean();
-    importedFile = (0, path_js_1.toPosixPath)(importedFile);
-    return { importedFile, err: undefined, hasFailed: false };
 }
-function requireResolveOptional(importPath, cwd) {
-    const res = requireResolve_(importPath, cwd);
+function requireResolveOptional({ importPath, importerFilePath, userRootDir }) {
+    const res = requireResolve_(importPath, importerFilePath, { userRootDir });
     if (res.hasFailed)
         return null;
-    return res.importedFile;
+    return res.importPathResolvedFilePath;
 }
-function requireResolveOptionalNonUserFile(importPath, cwd) {
-    const res = requireResolve_(importPath, cwd, { doNotHandleFileExtension: true });
+function requireResolveOptionalDir({ importPath, importerDir, userRootDir }) {
+    const importerFilePath = getFakeImporterFile(importerDir);
+    const res = requireResolve_(importPath, importerFilePath, { userRootDir });
     if (res.hasFailed)
         return null;
-    return res.importedFile;
-}
-function requireResolveNonUserFile(importPath, cwd) {
-    const res = requireResolve_(importPath, cwd, { doNotHandleFileExtension: true });
-    if (res.hasFailed)
-        throw res.err;
-    return res.importedFile;
+    return res.importPathResolvedFilePath;
 }
-function requireResolve(importPath, cwd) {
-    const res = requireResolve_(importPath, cwd);
+function requireResolveNpmPackage({ importPathNpmPackage, userRootDir }) {
+    (0, parseNpmPackage_js_1.assertIsImportPathNpmPackage)(importPathNpmPackage);
+    const importerFilePath = getFakeImporterFile(userRootDir);
+    const res = requireResolve_(importPathNpmPackage, importerFilePath, { userRootDir });
     if (res.hasFailed)
         throw res.err;
-    return res.importedFile;
+    return res.importPathResolvedFilePath;
 }
-function resolveCwd(cwd) {
-    let prefix = 'file://';
-    if (process.platform === 'win32')
-        prefix += '/';
-    if (cwd.startsWith(prefix)) {
-        cwd = cwd.slice(prefix.length);
-        cwd = node_path_1.default.posix.dirname(cwd);
+function requireResolveVikeDistFile(vikeDistFile) {
+    const vikeNodeModulesRoot = getVikeNodeModulesRoot();
+    (0, path_js_1.assertPosixPath)(vikeNodeModulesRoot);
+    (0, path_js_1.assertPosixPath)(vikeDistFile);
+    const importPathResolvedFilePath = node_path_1.default.posix.join(vikeNodeModulesRoot, vikeDistFile);
+    // Double check
+    {
+        const res = requireResolve_(importPathResolvedFilePath, 
+        // No context needed: importPathResolvedFilePath is already resolved and absolute
+        null, { doNotHandleFileExtension: true });
+        if (res.hasFailed)
+            throw res.err;
+        (0, assert_js_1.assert)(res.importPathResolvedFilePath === importPathResolvedFilePath);
     }
-    (0, assert_js_1.assert)(!cwd.startsWith('file:'));
-    return cwd;
+    return importPathResolvedFilePath;
+}
+function addExtraContextForNpmPackageImport(contexts, { importPath, userRootDir }) {
+    // We should add extra context only for npm packages, but unfortunately we cannot always disambiguate between npm package imports and path aliases.
+    if (!(0, parseNpmPackage_js_1.isImportPathNpmPackageOrPathAlias)(importPath))
+        return;
+    const userRootDirFakeFile = userRootDir && getFakeImporterFile(userRootDir);
+    [
+        // Workaround for monorepo resolve issue: https://github.com/vikejs/vike-react/pull/161/commits/dbaa6643e78015ac2797c237552800fef29b72a7
+        userRootDirFakeFile,
+        // I can't think of a use case where this would be needed, but let's add one extra last chance to sucessfully resolve some complex monorepo setups
+        importMetaUrl
+    ]
+        .filter(isNullish_js_1.isNotNullish)
+        .forEach((context) => {
+        const alreadyHasContext = contexts.includes(context) || contexts.includes(ensureFilePrefix(context));
+        if (alreadyHasContext)
+            return;
+        contexts.push(context);
+    });
 }
 function removeFileExtention(importPath) {
     // Skip for Bun: https://github.com/vikejs/vike/issues/2204
@@ -93,7 +158,7 @@ function removeFileExtention(importPath) {
     }
     return importPath;
 }
-function addFileExtensionsToRequireResolve() {
+function addFileExtensionsToRequireResolve(require_) {
     const added = [];
     isScriptFile_js_1.scriptFileExtensionList.forEach((ext) => {
         (0, assert_js_1.assert)(!ext.includes('.'));
@@ -103,10 +168,40 @@ function addFileExtensionsToRequireResolve() {
             added.push(ext);
         }
     });
-    const clean = () => {
-        added.forEach((ext) => {
-            delete require_.extensions[ext];
-        });
-    };
-    return clean;
+}
+function getVikeNodeModulesRoot() {
+    // [RELATIVE_PATH_FROM_DIST] Current file: vike/dist/esm/utils/requireResolve.js
+    (0, assert_js_1.assert)(importMetaUrl.includes('/dist/esm/') || importMetaUrl.includes('/dist/cjs/'));
+    const vikeNodeModulesRoot = node_path_1.default.posix.join(removeFilePrefix(importMetaUrl), '../../../../');
+    return vikeNodeModulesRoot;
+}
+function getFakeImporterFile(dirPath) {
+    (0, path_js_1.assertPosixPath)(dirPath);
+    (0, assert_js_1.assert)(!dirPath.startsWith('file')); // The file:// prefix is bogus when used with path.posix.join()
+    const importerFilePath = node_path_1.default.posix.join(dirPath, 'fakeFileForNodeResolve.js');
+    return importerFilePath;
+}
+function ensureFilePrefix(filePath) {
+    (0, path_js_1.assertPosixPath)(filePath);
+    const filePrefix = getFilePrefix();
+    if (!filePath.startsWith(filePrefix)) {
+        (0, assert_js_1.assert)(!filePath.startsWith('file'));
+        filePath = filePrefix + filePath;
+    }
+    (0, assert_js_1.assert)(filePath.startsWith(filePrefix));
+    return filePath;
+}
+function removeFilePrefix(filePath) {
+    const filePrefix = getFilePrefix();
+    if (filePath.startsWith(filePrefix)) {
+        filePath = filePath.slice(filePrefix.length);
+    }
+    (0, assert_js_1.assert)(!filePath.startsWith('file'));
+    return filePath;
+}
+function getFilePrefix() {
+    let prefix = 'file://';
+    if (process.platform === 'win32')
+        prefix += '/';
+    return prefix;
 }

package/dist/esm/__internal/index.js

@@ -3,7 +3,7 @@ export { setGlobalContext_buildEntry } from '../node/runtime/globalContext.js';
 // Needed by vite-plugin-vercel
 export { route, getPagesAndRoutes };
 import { route as routeInternal } from '../shared/route/index.js';
-import { getGlobalContextInternal, initGlobalContext_getPagesAndRoutes } from '../node/runtime/globalContext.js';
+import { getGlobalContextServerInternal, initGlobalContext_getPagesAndRoutes } from '../node/runtime/globalContext.js';
 import { setNodeEnvProduction } from '../utils/assertSetup.js';
 /**
  * Used by {@link https://github.com/magne4000/vite-plugin-vercel|vite-plugin-vercel} to compute some rewrite rules and extract { isr } configs.
@@ -13,10 +13,10 @@ import { setNodeEnvProduction } from '../utils/assertSetup.js';
 async function getPagesAndRoutes() {
     setNodeEnvProduction();
     await initGlobalContext_getPagesAndRoutes();
-    const globalContext = await getGlobalContextInternal();
+    const { globalContext } = await getGlobalContextServerInternal();
     const { 
     //
-    pageRoutes, pageFilesAll, pageConfigs, allPageIds } = globalContext;
+    _pageRoutes: pageRoutes, _pageFilesAll: pageFilesAll, _pageConfigs: pageConfigs, _allPageIds: allPageIds } = globalContext;
     return {
         pageRoutes,
         pageFilesAll,

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

@@ -1,21 +1,40 @@
-export { createPageContext };
-declare function createPageContext(urlOriginal: string): Promise<{
-    _isPageContextObject: boolean;
+export { createPageContextClientSide };
+declare function createPageContextClientSide(urlOriginal: string): Promise<{
+    globalContext: {
+        isGlobalContext: true;
+        _virtualFileExports: unknown;
+        _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+        _pageConfigs: import("../../__internal/index.js").PageConfig[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../types/index.js").ConfigResolved;
+        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    } & {
+        isClientSide: true;
+    } & {
+        _pageRoutes: import("../../__internal/index.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+    };
+    _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+    _pageConfigs: import("../../__internal/index.js").PageConfig[];
+    _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
+    _pageRoutes: import("../../__internal/index.js").PageRoutes;
+    _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
     isClientSide: boolean;
     isPrerendering: boolean;
     urlOriginal: string;
-    _objectCreatedByVike: boolean;
     _urlHandler: null;
     _urlRewrite: null;
     _baseServer: string;
-    _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
-    _pageConfigs: import("../../__internal/index.js").PageConfig[];
-    _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
-    _allPageIds: string[];
-    _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
-    _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
 } & {
     urlParsed: import("./utils.js").UrlPublic;
     urlPathname: string;
     url: string;
+} & {
+    config: import("../../types/index.js").ConfigResolved;
+    _source: import("../../shared/page-configs/getPageConfigUserFriendly.js").Source;
+    _sources: import("../../shared/page-configs/getPageConfigUserFriendly.js").Sources;
+    _from: import("../../shared/page-configs/getPageConfigUserFriendly.js").From;
+    isPageContext: true;
 }>;

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

@@ -1,33 +1,34 @@
-export { createPageContext };
-import { getPageConfigsRuntime } from '../../shared/getPageConfigsRuntime.js';
+export { createPageContextClientSide };
+import { createPageContextShared } from '../../shared/createPageContextShared.js';
 import { getPageContextUrlComputed } from '../../shared/getPageContextUrlComputed.js';
-import { loadPageRoutes } from '../../shared/route/loadPageRoutes.js';
 import { getBaseServer } from './getBaseServer.js';
-import { assert, isBaseServer, objectAssign } from './utils.js';
-// @ts-ignore
-import * as virtualFileExports from 'virtual:vike:importUserCode:client:client-routing';
-const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal } = getPageConfigsRuntime(virtualFileExports);
-async function createPageContext(urlOriginal) {
-    const { pageRoutes, onBeforeRouteHook } = await loadPageRoutes(pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds);
+import { getGlobalContextClientInternal } from './globalContext.js';
+import { assert, augmentType, isBaseServer, objectAssign } from './utils.js';
+async function createPageContextClientSide(urlOriginal) {
+    const globalContext = await getGlobalContextClientInternal();
     const baseServer = getBaseServer();
     assert(isBaseServer(baseServer));
-    const pageContext = {
-        _isPageContextObject: true,
+    const pageContextCreated = {
+        /* Don't spread globalContext for now? Or never spread it as it leads to confusion? The convenience isn't worth the added confusion?
+        ...globalContext, // least precedence
+        */
+        globalContext,
+        _pageFilesAll: globalContext._pageFilesAll,
+        _pageConfigs: globalContext._pageConfigs,
+        _pageConfigGlobal: globalContext._pageConfigGlobal,
+        _allPageIds: globalContext._allPageIds,
+        _pageRoutes: globalContext._pageRoutes,
+        _onBeforeRouteHook: globalContext._onBeforeRouteHook,
         isClientSide: true,
         isPrerendering: false,
         urlOriginal,
-        _objectCreatedByVike: true,
         _urlHandler: null,
         _urlRewrite: null,
-        _baseServer: baseServer,
-        _pageFilesAll: pageFilesAll,
-        _pageConfigs: pageConfigs,
-        _pageConfigGlobal: pageConfigGlobal,
-        _allPageIds: allPageIds,
-        _pageRoutes: pageRoutes,
-        _onBeforeRouteHook: onBeforeRouteHook
+        _baseServer: baseServer
     };
-    const pageContextUrlComputed = getPageContextUrlComputed(pageContext);
-    objectAssign(pageContext, pageContextUrlComputed);
-    return pageContext;
+    const pageContextUrlComputed = getPageContextUrlComputed(pageContextCreated);
+    objectAssign(pageContextCreated, pageContextUrlComputed);
+    const pageContextAugmented = await createPageContextShared(pageContextCreated, globalContext._pageConfigGlobal);
+    augmentType(pageContextCreated, pageContextAugmented);
+    return pageContextCreated;
 }

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

@@ -3,11 +3,11 @@ export { getPageContextFromHooks_serialized };
 export { getPageContextFromServerHooks };
 export { getPageContextFromClientHooks };
 export { setPageContextInitIsPassedToClient };
-import { assert, assertUsage, hasProp, objectAssign, getProjectError, redirectHard, executeHook, isObject, getGlobalObject } from './utils.js';
+import { assert, assertUsage, hasProp, objectAssign, getProjectError, redirectHard, isObject, getGlobalObject } from './utils.js';
 import { parse } from '@brillout/json-serializer/parse';
-import { getPageContextSerializedInHtml } from '../shared/getPageContextSerializedInHtml.js';
+import { getPageContextSerializedInHtml } from '../shared/getJsonSerializedInHtml.js';
 import { analyzePageServerSide } from '../../shared/getPageFiles/analyzePageServerSide.js';
-import { getHook } from '../../shared/hooks/getHook.js';
+import { getHookFromPageContext } from '../../shared/hooks/getHook.js';
 import { preparePageContextForUserConsumptionClientSide } from '../shared/preparePageContextForUserConsumptionClientSide.js';
 import { removeBuiltInOverrides } from './getPageContext/removeBuiltInOverrides.js';
 import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl.js';
@@ -18,6 +18,7 @@ import { executeGuardHook } from '../../shared/route/executeGuardHook.js';
 import { AbortRender, isAbortPageContext } from '../../shared/route/abort.js';
 import { pageContextInitIsPassedToClient } from '../../shared/misc/pageContextInitIsPassedToClient.js';
 import { isServerSideError } from '../../shared/misc/isServerSideError.js';
+import { executeHook } from '../../shared/hooks/executeHook.js';
 const globalObject = getGlobalObject('client-routing-runtime/getPageContextFromHooks.ts', {});
 // TODO/eventually: rename
 function getPageContextFromHooks_serialized() {
@@ -101,7 +102,7 @@ async function getPageContextFromClientHooks(pageContext, isErrorPage) {
     return pageContextFromClientHooks;
 }
 async function executeHookClientSide(hookName, pageContext) {
-    const hook = getHook(pageContext, hookName);
+    const hook = getHookFromPageContext(pageContext, hookName);
     if (!hook) {
         // No hook defined or hook's env.client is false
         return {};

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

@@ -0,0 +1,20 @@
+export { getGlobalContextClientInternal };
+export type { GlobalContextClient };
+import type { GlobalContextSharedPublic } from '../../shared/createGlobalContextShared.js';
+type GlobalContextClient = GlobalContextSharedPublic & Pick<GlobalContextClientInternal, 'isClientSide'> & Vike.GlobalContext & Vike.GlobalContextClient & {};
+type GlobalContextClientInternal = Awaited<ReturnType<typeof getGlobalContextClientInternal>>;
+declare const getGlobalContextClientInternal: () => Promise<{
+    isGlobalContext: true;
+    _virtualFileExports: unknown;
+    _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+    _pageConfigs: import("../../__internal/index.js").PageConfig[];
+    _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
+    config: import("../../types/index.js").ConfigResolved;
+    pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+} & {
+    isClientSide: true;
+} & {
+    _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+    _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+}>;

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

@@ -0,0 +1,13 @@
+export { getGlobalContextClientInternal };
+import { createGetGlobalContextClient } from '../shared/createGetGlobalContextClient.js';
+import { loadPageRoutes } from '../../shared/route/loadPageRoutes.js';
+// @ts-ignore
+import * as virtualFileExports from 'virtual:vike:importUserCode:client:client-routing';
+const getGlobalContextClientInternal = createGetGlobalContextClient(virtualFileExports, true, addGlobalContext);
+async function addGlobalContext(globalContext) {
+    const { pageRoutes, onBeforeRouteHook } = await loadPageRoutes(globalContext._pageFilesAll, globalContext._pageConfigs, globalContext._pageConfigGlobal, globalContext._allPageIds);
+    return {
+        _pageRoutes: pageRoutes,
+        _onBeforeRouteHook: onBeforeRouteHook
+    };
+}

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

@@ -3,9 +3,9 @@ import { isSameAsCurrentUrl, skipLink } from './skipLink.js';
 import { renderPageClientSide } from './renderPageClientSide.js';
 import { scrollToHashOrTop } from './setScrollPosition.js';
 function initOnLinkClick() {
-    document.addEventListener('click', onClick);
+    document.addEventListener('click', onLinkClick);
 }
-async function onClick(ev) {
+async function onLinkClick(ev) {
     if (!isNormalLeftClick(ev))
         return;
     const linkTag = findLinkTag(ev.target);

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

@@ -10,7 +10,7 @@ import { isErrorFetchingStaticAssets, loadUserFilesClientSide } from '../shared/
 import { skipLink } from './skipLink.js';
 import { disableClientRouting } from './renderPageClientSide.js';
 import { isClientSideRoutable } from './isClientSideRoutable.js';
-import { createPageContext } from './createPageContext.js';
+import { createPageContextClientSide } from './createPageContext.js';
 import { route } from '../../shared/route/index.js';
 import { noRouteMatch } from '../../shared/route/noRouteMatch.js';
 import { getPageContextFromServerHooks } from './getPageContextFromHooks.js';
@@ -238,7 +238,7 @@ function isExpired(found) {
 }
 // TODO/next-major-release: make it sync
 async function getPageContextLink(urlOfLink) {
-    const pageContextLink = await createPageContext(urlOfLink);
+    const pageContextLink = await createPageContextClientSide(urlOfLink);
     let pageContextFromRoute;
     try {
         pageContextFromRoute = await route(pageContextLink);

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

@@ -3,13 +3,13 @@ export { getRenderCount };
 export { disableClientRouting };
 export { firstRenderStartPromise };
 export { getPageContextClient };
-import { assert, isSameErrorMessage, objectAssign, redirectHard, getGlobalObject, executeHook, hasProp, augmentType, genPromise, isCallable, catchInfiniteLoop } from './utils.js';
+import { assert, isSameErrorMessage, objectAssign, redirectHard, getGlobalObject, hasProp, augmentType, genPromise, isCallable, catchInfiniteLoop } from './utils.js';
 import { getPageContextFromClientHooks, getPageContextFromServerHooks, getPageContextFromHooks_isHydration, getPageContextFromHooks_serialized, setPageContextInitIsPassedToClient } from './getPageContextFromHooks.js';
-import { createPageContext } from './createPageContext.js';
+import { createPageContextClientSide } from './createPageContext.js';
 import { addLinkPrefetchHandlers, addLinkPrefetchHandlers_unwatch, addLinkPrefetchHandlers_watch, getPageContextPrefetched, populatePageContextPrefetchCache } from './prefetch.js';
 import { assertInfo, assertWarning, isReact } from './utils.js';
 import { executeOnRenderClientHook } from '../shared/executeOnRenderClientHook.js';
-import { assertHook, getHook } from '../../shared/hooks/getHook.js';
+import { assertHook, getHookFromPageContext } from '../../shared/hooks/getHook.js';
 import { isErrorFetchingStaticAssets, loadUserFilesClientSide } from '../shared/loadUserFilesClientSide.js';
 import { pushHistoryState } from './history.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
@@ -21,6 +21,7 @@ import { getErrorPageId } from '../../shared/error-page.js';
 import { setPageContextCurrent } from './getPageContextCurrent.js';
 import { getRouteStringParameterList } from '../../shared/route/resolveRouteString.js';
 import { getCurrentUrl } from '../shared/getCurrentUrl.js';
+import { executeHook } from '../../shared/hooks/executeHook.js';
 const globalObject = getGlobalObject('client-routing-runtime/renderPageClientSide.ts', (() => {
     const { promise: firstRenderStartPromise, resolve: firstRenderStartPromiseResolve } = genPromise();
     return {
@@ -62,7 +63,7 @@ async function renderPageClientSide(renderArgs) {
             assertHook(previousPageContext, 'onPageTransitionStart');
             if (!globalObject.isTransitioning) {
                 globalObject.isTransitioning = true;
-                const onPageTransitionStartHook = getHook(previousPageContext, 'onPageTransitionStart');
+                const onPageTransitionStartHook = getHookFromPageContext(previousPageContext, 'onPageTransitionStart');
                 if (onPageTransitionStartHook) {
                     const hook = onPageTransitionStartHook;
                     const { hookFn } = hook;
@@ -215,7 +216,7 @@ async function renderPageClientSide(renderArgs) {
         }
     }
     async function getPageContextBegin(isForErrorPage) {
-        const pageContext = await createPageContext(urlOriginal);
+        const pageContext = await createPageContextClientSide(urlOriginal);
         objectAssign(pageContext, {
             isBackwardNavigation,
             isClientSideNavigation,
@@ -429,7 +430,7 @@ async function renderPageClientSide(renderArgs) {
         // onHydrationEnd()
         if (isFirstRender && !onRenderClientError) {
             assertHook(pageContext, 'onHydrationEnd');
-            const hook = getHook(pageContext, 'onHydrationEnd');
+            const hook = getHookFromPageContext(pageContext, 'onHydrationEnd');
             if (hook) {
                 const { hookFn } = hook;
                 try {
@@ -452,7 +453,7 @@ async function renderPageClientSide(renderArgs) {
             globalObject.isTransitioning = undefined;
             assert(previousPageContext);
             assertHook(previousPageContext, 'onPageTransitionEnd');
-            const hook = getHook(previousPageContext, 'onPageTransitionEnd');
+            const hook = getHookFromPageContext(previousPageContext, 'onPageTransitionEnd');
             if (hook) {
                 const { hookFn } = hook;
                 try {

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

@@ -1,6 +1,5 @@
 export * from '../../utils/assert.js';
 export * from '../../utils/assertSingleInstance.js';
-export * from '../../shared/hooks/executeHook.js';
 export * from '../../utils/getGlobalObject.js';
 export * from '../../utils/hasProp.js';
 export * from '../../utils/isBrowser.js';

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

@@ -4,7 +4,6 @@ import { onLoad } from './onLoad.js';
 onLoad();
 export * from '../../utils/assert.js';
 export * from '../../utils/assertSingleInstance.js';
-export * from '../../shared/hooks/executeHook.js';
 export * from '../../utils/getGlobalObject.js';
 export * from '../../utils/hasProp.js';
 export * from '../../utils/isBrowser.js';

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

@@ -0,0 +1 @@
+export { getGlobalContext, getGlobalContext as getGlobalContextAsync, getGlobalContextSync } from './shared/createGetGlobalContextClient.js';

package/dist/esm/client/index.js

@@ -0,0 +1,4 @@
+import { isBrowser } from '../utils/isBrowser.js';
+import { assert } from '../utils/assert.js';
+assert(isBrowser());
+export { getGlobalContext, getGlobalContext as getGlobalContextAsync, getGlobalContextSync } from './shared/createGetGlobalContextClient.js';

package/dist/esm/client/node.js

@@ -1,9 +1,7 @@
 import { assertUsage } from './server-routing-runtime/utils.js';
 assertUsage(false, [
-    'Following imports are forbidden on the client-side:',
+    'Server imports are forbidden on the client-side:',
     "  import { something } from 'vike/server'",
-    // TODO/v1-release: remove this line (also remove s above in `s/Following imports/Following import/`)
-    "  import { something } from 'vike'",
     'Did you mean the following instead?',
     "  import { something } from 'vike/client/router'"
 ].join('\n'), { showStackTrace: true });

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

@@ -0,0 +1,36 @@
+export { createPageContextClientSide };
+declare function createPageContextClientSide(): Promise<{
+    globalContext: {
+        isGlobalContext: true;
+        _virtualFileExports: unknown;
+        _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+        _pageConfigs: import("../../__internal/index.js").PageConfig[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../types/index.js").ConfigResolved;
+        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    } & {
+        isClientSide: true;
+    } & object;
+    _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+    _pageConfigs: import("../../__internal/index.js").PageConfig[];
+    _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
+    isPrerendering: boolean;
+    isClientSide: boolean;
+    isHydration: true;
+    isBackwardNavigation: null;
+    _hasPageContextFromServer: true;
+    _hasPageContextFromClient: false;
+} & {
+    pageId: string;
+    routeParams: Record<string, string>;
+} & import("../../shared/getPageFiles.js").PageConfigUserFriendlyOld & {
+    _pageFilesLoaded: import("../../shared/getPageFiles.js").PageFile[];
+} & {
+    config: import("../../types/index.js").ConfigResolved;
+    _source: import("../../shared/page-configs/getPageConfigUserFriendly.js").Source;
+    _sources: import("../../shared/page-configs/getPageConfigUserFriendly.js").Sources;
+    _from: import("../../shared/page-configs/getPageConfigUserFriendly.js").From;
+    isPageContext: true;
+}>;