vike 0.4.228-commit-84954ae → 0.4.228-commit-1bb55f1

package/dist/cjs/utils/requireResolve.js

@@ -16,93 +16,117 @@ 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");
 // @ts-ignore `file:///${__filename.split('\\').join('/')}` is shimmed at dist/cjs by dist-cjs-fixup.js.
 const importMetaUrl = `file:///${__filename.split('\\').join('/')}`;
+(0, path_js_1.assertPosixPath)(importMetaUrl);
 (0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
 (0, assertSetup_js_1.assertIsNotProductionRuntime)();
-function requireResolve_(importPath, importerFile, options) {
-    (0, path_js_1.assertPosixPath)(importerFile);
+// - 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);
-    (0, path_js_1.assertPosixPath)(importMetaUrl);
-    (0, assert_js_1.assert)(node_path_1.default.posix.basename(importerFile).includes('.'), { cwd: importerFile });
-    const importerPath = addFilePrefix(importerFile);
-    const require_ = (0, node_module_1.createRequire)(importerPath);
-    if (!options?.doNotHandleFileExtension) {
-        addFileExtensionsToRequireResolve(require_);
-        importPath = removeFileExtention(importPath);
+    const contexts = importerFilePath
+        ? [importerFilePath]
+        : [userRootDir ? getFakeImporterFile(userRootDir) : importMetaUrl];
+    addExtraContextForNpmPackageImport(contexts, { importPath, userRootDir });
+    let importPathResolvedFilePath;
+    let failure;
+    for (const context of contexts) {
+        (0, path_js_1.assertPosixPath)(context);
+        const require_ = (0, node_module_1.createRequire)(ensureFilePrefix(context));
+        if (!doNotHandleFileExtension) {
+            addFileExtensionsToRequireResolve(require_);
+            importPath = removeFileExtention(importPath);
+        }
+        try {
+            importPathResolvedFilePath = require_.resolve(importPath);
+        }
+        catch (err) {
+            /* DEBUG
+            console.log('err', err)
+            console.log('importPath', importPath)
+            console.log('importerFilePath', importerFilePath)
+            console.log('context', context)
+            console.log('importMetaUrl', importMetaUrl)
+            console.log('paths', paths)
+            //*/
+            failure ?? (failure = { err });
+        }
+        if (importPathResolvedFilePath)
+            break;
     }
-    const paths = !options?.paths
-        ? undefined
-        : [
-            // Seems like `importerPath` gets overriden by the `paths` argument, so we add it to `paths`. (For example, passing an empty array to `paths` kills the argument passed to `createRequire()`.)
-            toDirPath(importerFile),
-            ...(options?.paths || [])
-        ];
-    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 });
+    if (!importPathResolvedFilePath) {
+        (0, assert_js_1.assert)(failure);
+        return { importPathResolvedFilePath: undefined, err: failure.err, hasFailed: true };
     }
-    catch (err) {
-        return { importedFile: undefined, err, hasFailed: true };
+    else {
+        (0, assert_js_1.assert)(importPathResolvedFilePath);
+        importPathResolvedFilePath = (0, path_js_1.toPosixPath)(importPathResolvedFilePath);
+        return { importPathResolvedFilePath, err: undefined, hasFailed: false };
     }
-    importedFile = (0, path_js_1.toPosixPath)(importedFile);
-    return { importedFile, err: undefined, hasFailed: false };
 }
-function requireResolveOptional({ importPath, importerFile, userRootDir }) {
-    const paths = getExtraPathsForNpmPackageImport({ importPath, userRootDir });
-    const res = requireResolve_(importPath, importerFile, { paths });
+function requireResolveOptional({ importPath, importerFilePath, userRootDir }) {
+    const res = requireResolve_(importPath, importerFilePath, { userRootDir });
     if (res.hasFailed)
         return null;
-    return res.importedFile;
+    return res.importPathResolvedFilePath;
 }
 function requireResolveOptionalDir({ importPath, importerDir, userRootDir }) {
-    const importerFile = getFakeFilePath(importerDir);
-    const paths = getExtraPathsForNpmPackageImport({ importPath, userRootDir });
-    const res = requireResolve_(importPath, importerFile, { paths });
+    const importerFilePath = getFakeImporterFile(importerDir);
+    const res = requireResolve_(importPath, importerFilePath, { userRootDir });
     if (res.hasFailed)
         return null;
-    return res.importedFile;
+    return res.importPathResolvedFilePath;
 }
 function requireResolveNpmPackage({ importPathNpmPackage, userRootDir }) {
     (0, parseNpmPackage_js_1.assertIsImportPathNpmPackage)(importPathNpmPackage);
-    const importerFile = getFakeFilePath(userRootDir);
-    const paths = getExtraPathsForNpmPackageImport({ importPath: importPathNpmPackage, userRootDir });
-    const res = requireResolve_(importPathNpmPackage, importerFile, { paths });
+    const importerFilePath = getFakeImporterFile(userRootDir);
+    const res = requireResolve_(importPathNpmPackage, importerFilePath, { userRootDir });
     if (res.hasFailed)
         throw res.err;
-    return res.importedFile;
+    return res.importPathResolvedFilePath;
 }
 function requireResolveVikeDistFile(vikeDistFile) {
     const vikeNodeModulesRoot = getVikeNodeModulesRoot();
     (0, path_js_1.assertPosixPath)(vikeNodeModulesRoot);
     (0, path_js_1.assertPosixPath)(vikeDistFile);
-    const importedFile = node_path_1.default.posix.join(vikeNodeModulesRoot, vikeDistFile);
+    const importPathResolvedFilePath = node_path_1.default.posix.join(vikeNodeModulesRoot, vikeDistFile);
     // Double check
     {
-        const res = requireResolve_(importedFile, 
-        // Passing some dummy context as the context isn't needed since importerFile is already resolved and absolute
-        importMetaUrl, { doNotHandleFileExtension: true });
+        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.importedFile === importedFile);
+        (0, assert_js_1.assert)(res.importPathResolvedFilePath === importPathResolvedFilePath);
     }
-    return importedFile;
+    return importPathResolvedFilePath;
 }
-function getExtraPathsForNpmPackageImport({ importPath, userRootDir }) {
-    if (
-    // Ideally we'd set `paths` only for npm packages, but unfortunately we cannot always disambiguate between npm package imports and path aliases.
-    !(0, parseNpmPackage_js_1.isImportPathNpmPackageOrPathAlias)(importPath)) {
-        return undefined;
-    }
-    const paths = [
+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
-        userRootDir,
-        // I can't think of a use case where this would be needed, but let's add it to be extra safe
-        toDirPath(importMetaUrl)
-    ];
-    return paths;
+        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
@@ -137,16 +161,14 @@ function getVikeNodeModulesRoot() {
     const vikeNodeModulesRoot = node_path_1.default.posix.join(removeFilePrefix(importMetaUrl), '../../../../');
     return vikeNodeModulesRoot;
 }
-function toDirPath(filePath) {
-    return node_path_1.default.posix.dirname(removeFilePrefix(filePath));
-}
-function getFakeFilePath(dirPath) {
+function getFakeImporterFile(dirPath) {
     (0, path_js_1.assertPosixPath)(dirPath);
-    (0, assert_js_1.assert)(!dirPath.startsWith('file')); // The file:// prefix is bogus with path.join
-    const filePath = node_path_1.default.posix.join(dirPath, 'fakeFileForNodeResolve.js');
-    return filePath;
+    (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 addFilePrefix(filePath) {
+function ensureFilePrefix(filePath) {
+    (0, path_js_1.assertPosixPath)(filePath);
     const filePrefix = getFilePrefix();
     if (!filePath.startsWith(filePrefix)) {
         (0, assert_js_1.assert)(!filePath.startsWith('file'));

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,7 +13,7 @@ import { setNodeEnvProduction } from '../utils/assertSetup.js';
 async function getPagesAndRoutes() {
     setNodeEnvProduction();
     await initGlobalContext_getPagesAndRoutes();
-    const { globalContext } = await getGlobalContextInternal();
+    const { globalContext } = await getGlobalContextServerInternal();
     const { 
     //
     _pageRoutes: pageRoutes, _pageFilesAll: pageFilesAll, _pageConfigs: pageConfigs, _allPageIds: allPageIds } = globalContext;

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

@@ -1,6 +1,7 @@
 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[];
@@ -8,7 +9,9 @@ declare function createPageContextClientSide(urlOriginal: string): Promise<{
         _allPageIds: string[];
         config: import("../../types/index.js").ConfigResolved;
         pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
-    } & object & {
+    } & {
+        isClientSide: true;
+    } & {
         _pageRoutes: import("../../__internal/index.js").PageRoutes;
         _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
     };
@@ -33,5 +36,5 @@ declare function createPageContextClientSide(urlOriginal: string): Promise<{
     _source: import("../../shared/page-configs/getPageConfigUserFriendly.js").Source;
     _sources: import("../../shared/page-configs/getPageConfigUserFriendly.js").Sources;
     _from: import("../../shared/page-configs/getPageConfigUserFriendly.js").From;
-    _isPageContextObject: boolean;
+    isPageContext: true;
 }>;

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

@@ -2,10 +2,10 @@ export { createPageContextClientSide };
 import { createPageContextShared } from '../../shared/createPageContextShared.js';
 import { getPageContextUrlComputed } from '../../shared/getPageContextUrlComputed.js';
 import { getBaseServer } from './getBaseServer.js';
-import { getGlobalContext } from './globalContext.js';
+import { getGlobalContextClientInternal } from './globalContext.js';
 import { assert, augmentType, isBaseServer, objectAssign } from './utils.js';
 async function createPageContextClientSide(urlOriginal) {
-    const globalContext = await getGlobalContext();
+    const globalContext = await getGlobalContextClientInternal();
     const baseServer = getBaseServer();
     assert(isBaseServer(baseServer));
     const pageContextCreated = {

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

@@ -1,8 +1,10 @@
-export { getGlobalContext };
+export { getGlobalContextClientInternal };
 export type { GlobalContextClient };
 import type { GlobalContextSharedPublic } from '../../shared/createGlobalContextShared.js';
-type GlobalContextClient = GlobalContextSharedPublic & Vike.GlobalContext & Vike.GlobalContextClient & {};
-declare const getGlobalContext: () => Promise<{
+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[];
@@ -10,7 +12,9 @@ declare const getGlobalContext: () => Promise<{
     _allPageIds: string[];
     config: import("../../types/index.js").ConfigResolved;
     pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
-} & object & {
+} & {
+    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

@@ -1,9 +1,9 @@
-export { getGlobalContext };
-import { createGetGlobalContext } from '../shared/createGetGlobalContext.js';
+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 getGlobalContext = createGetGlobalContext(virtualFileExports, true, addGlobalContext);
+const getGlobalContextClientInternal = createGetGlobalContextClient(virtualFileExports, true, addGlobalContext);
 async function addGlobalContext(globalContext) {
     const { pageRoutes, onBeforeRouteHook } = await loadPageRoutes(globalContext._pageFilesAll, globalContext._pageConfigs, globalContext._pageConfigGlobal, globalContext._allPageIds);
     return {

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

@@ -1,6 +1,7 @@
 export { createPageContextClientSide };
 declare function createPageContextClientSide(): Promise<{
     globalContext: {
+        isGlobalContext: true;
         _virtualFileExports: unknown;
         _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
         _pageConfigs: import("../../__internal/index.js").PageConfig[];
@@ -8,6 +9,8 @@ declare function createPageContextClientSide(): Promise<{
         _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[];
@@ -29,5 +32,5 @@ declare function createPageContextClientSide(): Promise<{
     _source: import("../../shared/page-configs/getPageConfigUserFriendly.js").Source;
     _sources: import("../../shared/page-configs/getPageConfigUserFriendly.js").Sources;
     _from: import("../../shared/page-configs/getPageConfigUserFriendly.js").From;
-    _isPageContextObject: boolean;
+    isPageContext: true;
 }>;

package/dist/esm/client/server-routing-runtime/createPageContextClientSide.js

@@ -4,10 +4,10 @@ import { getPageContextSerializedInHtml } from '../shared/getJsonSerializedInHtm
 import { loadUserFilesClientSide } from '../shared/loadUserFilesClientSide.js';
 import { getCurrentUrl } from '../shared/getCurrentUrl.js';
 import { createPageContextShared } from '../../shared/createPageContextShared.js';
-import { getGlobalContext } from './globalContext.js';
+import { getGlobalContextClientInternal } from './globalContext.js';
 const urlFirst = getCurrentUrl({ withoutHash: true });
 async function createPageContextClientSide() {
-    const globalContext = await getGlobalContext();
+    const globalContext = await getGlobalContextClientInternal();
     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

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

@@ -1,8 +1,10 @@
-export { getGlobalContext };
+export { getGlobalContextClientInternal };
 export type { GlobalContextClientWithServerRouting };
 import type { GlobalContextSharedPublic } from '../../shared/createGlobalContextShared.js';
-type GlobalContextClientWithServerRouting = GlobalContextSharedPublic & Vike.GlobalContext & Vike.GlobalContextClient & {};
-declare const getGlobalContext: () => Promise<{
+type GlobalContextClientWithServerRouting = 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[];
@@ -10,4 +12,6 @@ declare const getGlobalContext: () => Promise<{
     _allPageIds: string[];
     config: import("../../types/index.js").ConfigResolved;
     pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+} & {
+    isClientSide: true;
 } & object>;

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

@@ -1,5 +1,5 @@
-export { getGlobalContext };
-import { createGetGlobalContext } from '../shared/createGetGlobalContext.js';
+export { getGlobalContextClientInternal };
+import { createGetGlobalContextClient } from '../shared/createGetGlobalContextClient.js';
 // @ts-ignore
 import * as virtualFileExports from 'virtual:vike:importUserCode:client:server-routing';
-const getGlobalContext = createGetGlobalContext(virtualFileExports, false);
+const getGlobalContextClientInternal = createGetGlobalContextClient(virtualFileExports, false);

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

@@ -0,0 +1,23 @@
+export { getGlobalContext };
+export { getGlobalContextSync };
+export { createGetGlobalContextClient };
+import { type GlobalContextShared } from '../../shared/createGlobalContextShared.js';
+declare function createGetGlobalContextClient<GlobalContextAddendum extends object>(virtualFileExports: unknown, isClientRouting: boolean, addGlobalContext?: (globalContext: GlobalContextShared) => Promise<GlobalContextAddendum>): () => 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;
+} & Awaited<{
+    /**
+     * Whether the environment is client-side or server-side / pre-rendering.
+     *
+     * We recommend using `import.meta.env.SSR` instead, see https://vike.dev/globalContext
+     */
+    isClientSide: true;
+} & Awaited<GlobalContextAddendum>>>;
+declare function getGlobalContext(): Promise<never>;
+declare function getGlobalContextSync(): never;

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

@@ -0,0 +1,58 @@
+// Public usage
+export { getGlobalContext };
+export { getGlobalContextSync };
+// Internal usage
+export { createGetGlobalContextClient };
+import { createGlobalContextShared, getGlobalContextSyncErrMsg } from '../../shared/createGlobalContextShared.js';
+import { getGlobalContextSerializedInHtml } from './getJsonSerializedInHtml.js';
+import { assert, assertUsage, genPromise, getGlobalObject, objectAssign } from './utils.js';
+const globalObject = getGlobalObject('createGetGlobalContextClient.ts', (() => {
+    const { promise: globalContextPromise, resolve: globalContextPromiseResolve } = genPromise();
+    return {
+        globalContextPromise,
+        globalContextPromiseResolve
+    };
+})());
+function createGetGlobalContextClient(virtualFileExports, isClientRouting, addGlobalContext) {
+    assert(globalObject.isClientRouting === undefined || globalObject.isClientRouting === isClientRouting);
+    globalObject.isClientRouting = isClientRouting;
+    // Eagerly call onCreateGlobalContext() hook
+    getGlobalContext();
+    return getGlobalContext;
+    async function getGlobalContext() {
+        // Cache
+        if (globalObject.globalContext &&
+            // Don't break HMR
+            globalObject.globalContext._virtualFileExports !== virtualFileExports) {
+            return globalObject.globalContext;
+        }
+        // Create
+        const globalContext = await createGlobalContextShared(virtualFileExports, globalObject, async (globalContext) => {
+            const globalContextAddendum = {
+                /**
+                 * Whether the environment is client-side or server-side / pre-rendering.
+                 *
+                 * We recommend using `import.meta.env.SSR` instead, see https://vike.dev/globalContext
+                 */
+                isClientSide: true
+            };
+            objectAssign(globalContextAddendum, getGlobalContextSerializedInHtml());
+            objectAssign(globalContextAddendum, await addGlobalContext?.(globalContext));
+            return globalContextAddendum;
+        });
+        assert(globalObject.globalContext);
+        globalObject.globalContextPromiseResolve(globalObject.globalContext);
+        // Return
+        return globalContext;
+    }
+}
+// The type is never used: it's the type of the server-side getGlobalContext() that is used.
+async function getGlobalContext() {
+    const globalContext = await globalObject.globalContextPromise;
+    return globalContext;
+}
+function getGlobalContextSync() {
+    const { globalContext } = globalObject;
+    assertUsage(globalContext, getGlobalContextSyncErrMsg);
+    return globalContext;
+}

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

@@ -3,3 +3,4 @@ export * from '../../utils/parseUrl.js';
 export * from '../../utils/getGlobalObject.js';
 export * from '../../utils/objectAssign.js';
 export * from '../../utils/hasProp.js';
+export * from '../../utils/genPromise.js';

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

@@ -3,3 +3,4 @@ export * from '../../utils/parseUrl.js';
 export * from '../../utils/getGlobalObject.js';
 export * from '../../utils/objectAssign.js';
 export * from '../../utils/hasProp.js';
+export * from '../../utils/genPromise.js';

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

@@ -153,14 +153,17 @@ function assertSingleInstance(config) {
 function assertVikeCliOrApi(config) {
     if (isVikeCliOrApi())
         return;
-    if (isVitest())
-        return;
     if (isViteCliCall()) {
+        assert(!isVitest());
         assertWarning(false, `Vite's CLI is deprecated ${pc.underline('https://vike.dev/migration/cli')}`, {
             onlyOnce: true
         });
         return;
     }
+    if (isVitest()) {
+        assertWarning(false, `Unexpected Vitest setup: you seem to be using Vitest together with Vike's Vite plugin but without using Vike's JavaScript API which is unexpected, see ${pc.underline('https://vike.dev/vitest')}`, { onlyOnce: true });
+        return;
+    }
     if (config.server.middlewareMode) {
         assertWarning(false, `${pc.cyan('vite.createServer()')} is deprecated ${pc.underline('https://vike.dev/migration/cli#api')}`, {
             onlyOnce: true

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

@@ -68,7 +68,7 @@ function resolveImportPathWithNode(pointerImportData, importerFilePath, userRoot
     // filePathAbsoluteFilesystem is null when pointerImportData.importPath is a path alias that Node.js doesn't know about
     const filePathAbsoluteFilesystem = requireResolveOptional({
         importPath: pointerImportData.importPath,
-        importerFile: importerFilePathAbsolute,
+        importerFilePath: importerFilePathAbsolute,
         userRootDir
     });
     if (!filePathAbsoluteFilesystem) {

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

@@ -207,7 +207,6 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                             //   - Vike doesn't resolve path aliases at all.
                             //   - Node.js doesn't support `tsconfig.js#compilerOptions.paths`.
                             // - Esbuild path alias resolution seems reliable, e.g. it supports `tsconfig.js#compilerOptions.paths`.
-                            assert(!isImportPathNpmPackageOrPathAlias(importPathOriginal));
                             importPathTranspiled = importPathResolved;
                         }
                         else {