vike 0.4.228-commit-4bed128 → 0.4.228-commit-0e9e0f2

package/dist/cjs/shared/getPageFiles/fileTypes.js

@@ -25,7 +25,7 @@ function determineFileType(filePath) {
         const isCSS = filePath.endsWith('.css');
         if (isCSS) {
             /* This assert() is skipped to reduce client-side bundle size
-            assert(isNpmPackageImport(filePath), filePath) // `.css` page files are only supported for npm packages
+            assert(isImportPathNpmPackage(filePath), filePath) // `.css` page files are only supported for npm packages
             */
             return '.css';
         }

package/dist/cjs/shared/page-configs/serialize/serializeConfigValues.js

@@ -8,7 +8,7 @@ exports.getConfigValuesBase = getConfigValuesBase;
 exports.isJsonValue = isJsonValue;
 const assertSetup_js_1 = require("../../../utils/assertSetup.js");
 const utils_js_1 = require("../../../node/plugin/utils.js");
-const transformPointerImports_js_1 = require("../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transformPointerImports.js");
+const pointerImports_js_1 = require("../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/pointerImports.js");
 const helpers_js_1 = require("../helpers.js");
 const stringify_1 = require("@brillout/json-serializer/stringify");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
@@ -134,7 +134,7 @@ function valueToJson(value, configName, definedAtData, importStatements, filesEn
             //   - https://github.com/vikejs/vike-react/pull/113
             replacer(_, value) {
                 if (typeof value === 'string') {
-                    const importData = (0, transformPointerImports_js_1.parsePointerImportData)(value);
+                    const importData = (0, pointerImports_js_1.parsePointerImportData)(value);
                     if (importData) {
                         const { importName } = addImportStatement(importStatements, importData.importPath, importData.exportName, filesEnv, configEnv, configName);
                         const replacement = [REPLACE_ME_BEFORE, importName, REPLACE_ME_AFTER].join('');
@@ -269,10 +269,10 @@ function addImportStatement(importStatements, importPath, exportName, filesEnv,
     return { importName };
 }
 function assertFileEnv(importPath, configEnv, configName, filesEnv) {
+    (0, utils_js_1.assert)(!(0, utils_js_1.isImportPathRelative)(importPath));
     const key = importPath;
     (0, utils_js_1.assert)(key);
     (0, utils_js_1.assertPosixPath)(key);
-    (0, utils_js_1.assert)(!isRelativeImportPath(key));
     if (!filesEnv.has(key)) {
         filesEnv.set(key, []);
     }
@@ -288,7 +288,3 @@ function assertFileEnv(importPath, configEnv, configName, filesEnv) {
         ].join('\n'));
     }
 }
-// TODO/now dedupe
-function isRelativeImportPath(importPath) {
-    return importPath.startsWith('./') || importPath.startsWith('../');
-}

package/dist/cjs/utils/PROJECT_VERSION.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = void 0;
 // Automatically updated by @brillout/release-me
-exports.PROJECT_VERSION = '0.4.228-commit-4bed128';
+exports.PROJECT_VERSION = '0.4.228-commit-0e9e0f2';

package/dist/cjs/utils/isImportPath.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isImportPath = isImportPath;
+exports.isImportPathRelative = isImportPathRelative;
+const path_js_1 = require("./path.js");
+const assert_js_1 = require("./assert.js");
+const parseNpmPackage_js_1 = require("./parseNpmPackage.js");
+function isImportPath(importPath) {
+    return isImportPathRelative(importPath) || (0, parseNpmPackage_js_1.isImportPathNpmPackageOrPathAlias)(importPath);
+}
+// See also `import { pathIsRelative } from './path'`
+function isImportPathRelative(importPath) {
+    (0, path_js_1.assertPosixPath)(importPath);
+    if (importPath.startsWith('./') || importPath.startsWith('../')) {
+        return true;
+    }
+    else {
+        (0, assert_js_1.assert)(!importPath.startsWith('.'));
+        return false;
+    }
+}

package/dist/cjs/utils/objectAssign.js

@@ -9,6 +9,6 @@ function objectAssign(obj, objAddendum, objAddendumCanBePageContextObject) {
     if (!objAddendum)
         return;
     if (!objAddendumCanBePageContextObject)
-        (0, assert_js_1.assert)(!('_isPageContextObject' in objAddendum));
+        (0, assert_js_1.assert)(!('isPageContext' in objAddendum));
     Object.defineProperties(obj, Object.getOwnPropertyDescriptors(objAddendum));
 }

package/dist/cjs/utils/{isNpmPackage.js → parseNpmPackage.js}

@@ -1,46 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNpmPackageImport = isNpmPackageImport;
-exports.isNpmPackageImport_unreliable = isNpmPackageImport_unreliable;
-exports.assertIsNpmPackageImport = assertIsNpmPackageImport;
-exports.isValidPathAlias = isValidPathAlias;
-exports.parse = parse;
+exports.isImportPathNpmPackage = isImportPathNpmPackage;
+exports.isImportPathNpmPackageOrPathAlias = isImportPathNpmPackageOrPathAlias;
+exports.assertIsImportPathNpmPackage = assertIsImportPathNpmPackage;
+exports.isPathAliasRecommended = isPathAliasRecommended;
+exports.parseNpmPackage = parseNpmPackage;
 exports.isDistinguishable = isDistinguishable;
 const assert_js_1 = require("./assert.js");
 const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
 (0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
-function isNpmPackageImport(str, { cannotBePathAlias }) {
+function isImportPathNpmPackage(str, { cannotBePathAlias }) {
     (0, assert_js_1.assert)(cannotBePathAlias);
-    return isNpmPackageImport_unreliable(str);
+    return isImportPathNpmPackageOrPathAlias(str);
 }
 // We cannot distinguish path aliases that look like npm package imports
-function isNpmPackageImport_unreliable(str) {
-    const res = parse(str);
+function isImportPathNpmPackageOrPathAlias(str) {
+    const res = parseNpmPackage(str);
     return res !== null;
 }
-function assertIsNpmPackageImport(str) {
-    (0, assert_js_1.assert)(isNpmPackageImport(str, {
-        // If `str` is a path alias that looks like an npm package => assertIsNpmPackageImport() is erroneous but that's okay because the assertion will eventually fail for some other user using a disambiguated path alias.
+function assertIsImportPathNpmPackage(str) {
+    (0, assert_js_1.assert)(isImportPathNpmPackage(str, {
+        // If `str` is a path alias that looks like an npm package => assertIsImportPathNpmPackage() is erroneous but that's okay because the assertion will eventually fail for some other user using a disambiguated path alias.
         cannotBePathAlias: true
     }), str);
 }
 function isNpmPackageName(str) {
-    const res = parse(str);
+    const res = parseNpmPackage(str);
     return res !== null && res.importPath === null;
 }
 function getNpmPackageName(str) {
-    const res = parse(str);
+    const res = parseNpmPackage(str);
     if (!res)
         return null;
     return res.pkgName;
 }
 function getNpmPackageImportPath(str) {
-    const res = parse(str);
+    const res = parseNpmPackage(str);
     if (!res)
         return null;
     return res.importPath;
 }
-function isValidPathAlias(alias) {
+function isPathAliasRecommended(alias) {
     // Cannot be distinguished from npm package names
     if (!isDistinguishable(alias))
         return false;
@@ -56,14 +56,14 @@ function isValidPathAlias(alias) {
     return true;
 }
 function isDistinguishable(alias) {
-    return (parse(alias) === null &&
-        parse(`${alias}fake-path`) === null &&
-        parse(`${alias}/fake-path`) === null &&
-        parse(`${alias}fake/deep/path`) === null &&
-        parse(`${alias}/fake/deep/path`) === null &&
+    return (parseNpmPackage(alias) === null &&
+        parseNpmPackage(`${alias}fake-path`) === null &&
+        parseNpmPackage(`${alias}/fake-path`) === null &&
+        parseNpmPackage(`${alias}fake/deep/path`) === null &&
+        parseNpmPackage(`${alias}/fake/deep/path`) === null &&
         // See note about '-' in ./isNpmPackageName.spec.ts
         // ```ts
-        // expect(parse('-')).toBe(null) // actually wrong: https://www.npmjs.com/package/-
+        // expect(parseNpmPackage('-')).toBe(null) // actually wrong: https://www.npmjs.com/package/-
         // ```
         !alias.startsWith('-'));
 }
@@ -71,7 +71,7 @@ function isDistinguishable(alias) {
 //  - https://www.npmjs.com/package/-
 // The correct logic is complex, see https://github.com/npm/validate-npm-package-name
 // We don't need to be accurate: are there npm packages with weird names that are actually being used?
-function parse(str) {
+function parseNpmPackage(str) {
     if (!str)
         return null;
     let scope = null;

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,118 @@ 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");
 // @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);
+// - 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 (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;
     }
-    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);
+        return { importPathResolvedFilePath: undefined, err: failure.err, hasFailed: true };
     }
-    catch (err) {
-        clean();
-        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 };
     }
-    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 +144,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 +154,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/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/globalContext.d.ts

@@ -1,8 +1,10 @@
 export { getGlobalContext };
 export type { GlobalContextClient };
 import type { GlobalContextSharedPublic } from '../../shared/createGlobalContextShared.js';
-type GlobalContextClient = GlobalContextSharedPublic & Vike.GlobalContext & Vike.GlobalContextClient & {};
+type GlobalContextClient = GlobalContextSharedPublic & Pick<GlobalContextClientInternal, 'isClientSide'> & Vike.GlobalContext & Vike.GlobalContextClient & {};
+type GlobalContextClientInternal = Awaited<ReturnType<typeof getGlobalContext>>;
 declare const getGlobalContext: () => 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/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/globalContext.d.ts

@@ -3,6 +3,7 @@ export type { GlobalContextClientWithServerRouting };
 import type { GlobalContextSharedPublic } from '../../shared/createGlobalContextShared.js';
 type GlobalContextClientWithServerRouting = GlobalContextSharedPublic & Vike.GlobalContext & Vike.GlobalContextClient & {};
 declare const getGlobalContext: () => Promise<{
+    isGlobalContext: true;
     _virtualFileExports: unknown;
     _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
     _pageConfigs: import("../../__internal/index.js").PageConfig[];
@@ -10,4 +11,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/shared/createGetGlobalContext.d.ts

@@ -1,6 +1,7 @@
 export { createGetGlobalContext };
 import { type GlobalContextShared } from '../../shared/createGlobalContextShared.js';
 declare function createGetGlobalContext<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[];
@@ -8,4 +9,11 @@ declare function createGetGlobalContext<GlobalContextAddendum extends object>(vi
     _allPageIds: string[];
     config: import("../../types/index.js").ConfigResolved;
     pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
-} & Awaited<object & Awaited<GlobalContextAddendum>>>;
+} & 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>>>;

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

@@ -18,7 +18,14 @@ function createGetGlobalContext(virtualFileExports, isClientRouting, addGlobalCo
         }
         // Create
         const globalContext = await createGlobalContextShared(virtualFileExports, globalObject, async (globalContext) => {
-            const globalContextAddendum = {};
+            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;

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

@@ -2,7 +2,7 @@ export { baseUrls };
 import { resolveBase } from '../../shared/resolveBase.js';
 import { assert } from '../utils.js';
 import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
-import { getVikeConfigPublic } from './commonConfig.js';
+import { getVikeConfigInternal } from './commonConfig.js';
 function baseUrls() {
     let basesResolved;
     return {
@@ -12,7 +12,7 @@ function baseUrls() {
             const isDev = config._isDev;
             assert(typeof isDev === 'boolean');
             const baseViteOriginal = config.base ?? '/__UNSET__'; // '/__UNSET__' because Vite resolves `_baseViteOriginal: null` to `undefined`
-            const vike = getVikeConfigPublic(config);
+            const vike = getVikeConfigInternal(config);
             basesResolved = resolveBase(baseViteOriginal, vike.config.baseServer ?? null, vike.config.baseAssets ?? null);
             // We cannot define these in configResolved() because Vite picks up the env variables before any configResolved() hook is called
             process.env.BASE_SERVER = basesResolved.baseServer;

package/dist/esm/node/plugin/plugins/build/handleAssetsManifest.js

@@ -15,7 +15,7 @@ import pc from '@brillout/picocolors';
 import { isV1Design } from '../importUserCode/v1-design/getVikeConfig.js';
 import { getOutDirs } from '../../shared/getOutDirs.js';
 import { isViteServerBuild_onlySsrEnv, isViteServerBuild } from '../../shared/isViteServerBuild.js';
-import { getVikeConfigPublic } from '../commonConfig.js';
+import { getVikeConfigInternal } from '../commonConfig.js';
 import { set_macro_ASSETS_MANIFEST } from './pluginBuildEntry.js';
 assertIsSingleModuleInstance('build/handleAssetsManifest.ts');
 let assetsJsonFilePath;
@@ -281,7 +281,7 @@ async function writeManifestFile(manifest, manifestFilePath) {
     await fs.writeFile(manifestFilePath, manifestFileContent, 'utf-8');
 }
 function handleAssetsManifest_getBuildConfig(config) {
-    const vike = getVikeConfigPublic(config);
+    const vike = getVikeConfigInternal(config);
     const isFixEnabled = handleAssetsManifest_isFixEnabled(config);
     return {
         // https://github.com/vikejs/vike/issues/1339

package/dist/esm/node/plugin/plugins/build/pluginBuildApp.js

@@ -2,7 +2,7 @@ export { pluginBuildApp };
 import { runPrerender_forceExit } from '../../../prerender/runPrerender.js';
 import { resolveOutDir } from '../../shared/getOutDirs.js';
 import { assert } from '../../utils.js';
-import { getVikeConfigPublic } from '../commonConfig.js';
+import { getVikeConfigInternal } from '../commonConfig.js';
 import { isPrerenderForceExit } from './pluginAutoFullBuild.js';
 function pluginBuildApp() {
     return [
@@ -10,7 +10,7 @@ function pluginBuildApp() {
             name: 'vike:build:pluginBuildApp',
             apply: 'build',
             config(config) {
-                const vike = getVikeConfigPublic(config);
+                const vike = getVikeConfigInternal(config);
                 if (!vike.config.vite6BuilderApp)
                     return;
                 return {