vike 0.4.196 → 0.4.197-commit-f4d8658

package/dist/cjs/client/client-routing-runtime/prefetch/PrefetchSetting.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/client/server-routing-runtime/onLoad.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onLoad = onLoad;
+const assertIsBrowser_js_1 = require("../../utils/assertIsBrowser.js");
+function onLoad() {
+    (0, assertIsBrowser_js_1.assertIsBrowser)();
+}

package/dist/cjs/client/server-routing-runtime/utils.js

@@ -0,0 +1,34 @@
+"use strict";
+// Utils needed by Server Routing.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// We assume all runtime entries will load this utils.ts file
+const onLoad_js_1 = require("./onLoad.js");
+(0, onLoad_js_1.onLoad)();
+__exportStar(require("../../utils/assert.js"), exports);
+__exportStar(require("../../utils/assertSingleInstance.js"), exports);
+__exportStar(require("../../shared/hooks/executeHook.js"), exports);
+__exportStar(require("../../utils/checkType.js"), exports); // Only used by Server Routing (not needed for Client Routing)
+__exportStar(require("../../utils/getCurrentUrl.js"), exports);
+__exportStar(require("../../utils/getGlobalObject.js"), exports);
+__exportStar(require("../../utils/hasProp.js"), exports);
+__exportStar(require("../../utils/isCallable.js"), exports);
+__exportStar(require("../../utils/isObject.js"), exports);
+__exportStar(require("../../utils/objectAssign.js"), exports);
+__exportStar(require("../../utils/parseUrl.js"), exports);
+__exportStar(require("../../utils/slice.js"), exports);
+__exportStar(require("../../utils/unique.js"), exports); // Only used by Server Routing (not needed for Client Routing)
+__exportStar(require("../../utils/getPropAccessNotation.js"), exports);

package/dist/cjs/client/shared/getPageContextProxyForUser.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPageContextProxyForUser = getPageContextProxyForUser;
+const utils_js_1 = require("../server-routing-runtime/utils.js");
+const notSerializable_js_1 = require("../../shared/notSerializable.js");
+const globalObject = (0, utils_js_1.getGlobalObject)('getPageContextProxyForUser.ts', {});
+/**
+ * Throw error when pageContext value isn't:
+ * - serializable, or
+ * - defined.
+ */
+function getPageContextProxyForUser(pageContext) {
+    (0, utils_js_1.assert)([true, false].includes(pageContext._hasPageContextFromServer));
+    (0, utils_js_1.assert)([true, false].includes(pageContext._hasPageContextFromClient));
+    return new Proxy(pageContext, {
+        get(_, prop) {
+            const val = pageContext[prop];
+            const propName = (0, utils_js_1.getPropAccessNotation)(prop);
+            (0, utils_js_1.assertUsage)(val !== notSerializable_js_1.notSerializable, `Can't access pageContext${propName} on the client side. Because it can't be serialized, see server logs.`);
+            passToClientHint(pageContext, prop, propName);
+            return val;
+        }
+    });
+}
+function passToClientHint(pageContext, prop, propName) {
+    if (handleVueReactivity(prop))
+        return;
+    // `prop in pageContext` is the trick we use to know the passToClient value on the client-side, as we set a value to all passToClient props, even `undefined` ones:
+    // ```html
+    // <script id="vike_pageContext" type="application/json">{"pageProps":"!undefined"}</script>
+    // ```
+    if (prop in pageContext)
+        return;
+    if (isWhitelisted(prop))
+        return;
+    // The trick described above (`prop in pageContext`) doesn't work if Vike doesn't fetch any pageContext from the server.
+    // - There would still be some value to show a warning, but it isn't worth it because of the confusion that the first recommendation (adding `prop` to `passToClient`) wouldn't actually remove the warning, and only the second recommendation (using `prop in pageContext` instead of `pageContext[prop]`) would work.
+    if (!pageContext._hasPageContextFromServer)
+        return;
+    const errMsg = `pageContext${propName} isn't defined on the client-side, see https://vike.dev/passToClient#error`;
+    if (
+    // TODO/next-major-release always make it an error.
+    // - Remove pageContext._hasPageContextFromClient logic (IIRC this is its only use case).
+    pageContext._hasPageContextFromClient) {
+        (0, utils_js_1.assertWarning)(false, errMsg, { onlyOnce: false, showStackTrace: true });
+    }
+    else {
+        (0, utils_js_1.assertUsage)(false, errMsg);
+    }
+}
+const WHITELIST = [
+    'then',
+    // Vue calls toJSON()
+    'toJSON'
+];
+function isWhitelisted(prop) {
+    if (WHITELIST.includes(prop))
+        return true;
+    if (typeof prop === 'symbol')
+        return true; // Vue tries to access some symbols
+    if (typeof prop !== 'string')
+        return true;
+    if (prop.startsWith('__v_'))
+        return true; // Vue internals upon `reactive(pageContext)`
+    return false;
+}
+// Handle Vue's reactivity.
+// When changing a reactive object:
+// - Vue tries to read its old value first. This triggers a `assertIsDefined()` failure if e.g. `pageContextReactive.routeParams = pageContextNew.routeParams` and `pageContextReactive` has no `routeParams`.
+// - Vue seems to read __v_raw before reading the property.
+function handleVueReactivity(prop) {
+    if (globalObject.prev === prop || globalObject.prev === '__v_raw')
+        return true;
+    globalObject.prev = prop;
+    window.setTimeout(() => {
+        globalObject.prev = undefined;
+    }, 0);
+    return false;
+}

package/dist/cjs/client/shared/preparePageContextForUserConsumptionClientSide.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preparePageContextForUserConsumptionClientSide = preparePageContextForUserConsumptionClientSide;
+const utils_js_1 = require("../server-routing-runtime/utils.js");
+const getPageContextProxyForUser_js_1 = require("./getPageContextProxyForUser.js");
+const preparePageContextForUserConsumption_js_1 = require("../../shared/preparePageContextForUserConsumption.js");
+function preparePageContextForUserConsumptionClientSide(pageContext, isClientRouting) {
+    if (isClientRouting) {
+        const pageContextTyped = pageContext;
+        (0, utils_js_1.assert)([true, false].includes(pageContextTyped.isHydration));
+        (0, utils_js_1.assert)([true, false, null].includes(pageContextTyped.isBackwardNavigation));
+    }
+    else {
+        const pageContextTyped = pageContext;
+        (0, utils_js_1.assert)(pageContextTyped.isHydration === true);
+        (0, utils_js_1.assert)(pageContextTyped.isBackwardNavigation === null);
+    }
+    const Page = pageContext.config.Page ||
+        // TODO/next-major-release: remove
+        pageContext.exports.Page;
+    (0, utils_js_1.objectAssign)(pageContext, { Page });
+    // TODO/next-major-release: remove
+    // - Requires https://github.com/vikejs/vike-vue/issues/198
+    // - Last time I tried to remove it (https://github.com/vikejs/vike/commit/705fd23598d9d69bf46a52c8550216cd7117ce71) the tests were failing as expected: only the Vue integrations that used shallowReactive() failed.
+    supportVueReactiviy(pageContext);
+    (0, preparePageContextForUserConsumption_js_1.preparePageContextForUserConsumption)(pageContext);
+    const pageContextProxy = (0, getPageContextProxyForUser_js_1.getPageContextProxyForUser)(pageContext);
+    return pageContextProxy;
+}
+// With Vue + Cient Routing, the `pageContext` is made reactive:
+// ```js
+// import { reactive } from 'vue'
+// // See /examples/vue-full/renderer/createVueApp.ts
+// const pageContextReactive = reactive(pageContext)
+// ```
+function supportVueReactiviy(pageContext) {
+    resolveGetters(pageContext);
+}
+// Remove propery descriptor getters because they break Vue's reactivity.
+// E.g. resolve the `pageContext.urlPathname` getter.
+function resolveGetters(pageContext) {
+    Object.entries(pageContext).forEach(([key, val]) => {
+        delete pageContext[key];
+        pageContext[key] = val;
+    });
+}

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

@@ -68,6 +68,11 @@ const configDefinitionsBuiltIn = {
     hydrationCanBeAborted: {
         env: { client: true }
     },
+    prefetch: {
+        env: { client: true },
+        eager: true
+    },
+    // TODO/v1-release: remove
     prefetchStaticAssets: {
         env: { client: true }
     },
@@ -101,10 +106,12 @@ const configDefinitionsBuiltIn = {
     },
     onBeforeRenderEnv: {
         env: { client: true },
+        eager: true,
         _computed: (configValueSources) => !isConfigSet(configValueSources, 'onBeforeRender') ? null : getConfigEnv(configValueSources, 'onBeforeRender')
     },
     dataEnv: {
         env: { client: true },
+        eager: true,
         _computed: (configValueSources) => !isConfigSet(configValueSources, 'data') ? null : getConfigEnv(configValueSources, 'data')
     },
     hooksTimeout: {
@@ -121,6 +128,9 @@ const configDefinitionsBuiltIn = {
     },
     require: {
         env: { config: true }
+    },
+    keepScrollPosition: {
+        env: { client: true }
     }
 };
 exports.configDefinitionsBuiltIn = configDefinitionsBuiltIn;
@@ -149,7 +159,13 @@ function getConfigEnv(configValueSources, configName) {
     const configValueSource = getConfigValueSource(configValueSources, configName);
     if (!configValueSource)
         return null;
-    return configValueSource.configEnv;
+    const { configEnv } = configValueSource;
+    const env = {};
+    if (configEnv.client)
+        env.client = true;
+    if (configEnv.server)
+        env.server = true;
+    return env;
 }
 function isConfigSet(configValueSources, configName) {
     const configValueSource = getConfigValueSource(configValueSources, configName);

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

@@ -11,7 +11,7 @@ const utils_js_1 = require("../../../../utils.js");
 const transpileAndExecuteFile_js_1 = require("./transpileAndExecuteFile.js");
 const assertPlusFileExport_js_1 = require("../../../../../../shared/page-configs/assertPlusFileExport.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const transformFileImports_js_1 = require("./transformFileImports.js");
+const transformPointerImports_js_1 = require("./transformPointerImports.js");
 const getConfigFileExport_js_1 = require("../getConfigFileExport.js");
 const resolvePointerImport_js_1 = require("./resolvePointerImport.js");
 (0, utils_js_1.assertIsNotProductionRuntime)();
@@ -94,7 +94,7 @@ function getExtendsPointerImportData(configFileExports, configFilePath) {
         (0, utils_js_1.assertUsage)(false, wrongUsage);
     }
     const extendsPointerImportData = extendList.map((importString) => {
-        const pointerImportData = (0, transformFileImports_js_1.parsePointerImportData)(importString);
+        const pointerImportData = (0, transformPointerImports_js_1.parsePointerImportData)(importString);
         (0, utils_js_1.assertUsage)(pointerImportData, wrongUsage);
         return pointerImportData;
     });

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

@@ -8,20 +8,20 @@ exports.resolvePointerImport = resolvePointerImport;
 exports.clearFilesEnvMap = clearFilesEnvMap;
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const utils_js_1 = require("../../../../utils.js");
-const transformFileImports_js_1 = require("./transformFileImports.js");
+const transformPointerImports_js_1 = require("./transformPointerImports.js");
 const path_1 = __importDefault(require("path"));
 const getFilePath_js_1 = require("../../../../shared/getFilePath.js");
 const filesEnvMap = new Map();
 function resolvePointerImportOfConfig(configValue, importerFilePath, userRootDir, configEnv, configName) {
     if (typeof configValue !== 'string')
         return null;
-    const pointerImportData = (0, transformFileImports_js_1.parsePointerImportData)(configValue);
+    const pointerImportData = (0, transformPointerImports_js_1.parsePointerImportData)(configValue);
     if (!pointerImportData)
         return null;
     const { importPath, exportName } = pointerImportData;
     const filePath = resolvePointerImport(pointerImportData, importerFilePath, userRootDir);
     const fileExportPathToShowToUser = exportName === 'default' || exportName === configName ? [] : [exportName];
-    assertFileEnv(filePath.filePathAbsoluteFilesystem, importPath, configEnv, configName);
+    assertUsageFileEnv(filePath.filePathAbsoluteFilesystem, importPath, configEnv, configName);
     return {
         ...filePath,
         fileExportName: exportName,
@@ -29,33 +29,36 @@ function resolvePointerImportOfConfig(configValue, importerFilePath, userRootDir
     };
 }
 function resolvePointerImport(pointerImportData, importerFilePath, userRootDir) {
+    // `importPath` should be one of the following:
+    // - A relative import path
+    // - A filesystem absolute path
+    // - An npm package import
     const { importPath } = pointerImportData;
     const filePathAbsoluteFilesystem = resolveImportPathWithNode(pointerImportData, importerFilePath);
     let filePath;
-    // - importPath is one of the following. (See `transpileAndExecuteFile()`.)
-    //   - A relative import path
-    //   - A filesystem absolute path
-    //   - An npm package import
-    // - importPath cannot be a path alias (since esbuild resolves path aliases, see transpileAndExecuteFile.ts)
     (0, utils_js_1.assertPosixPath)(importPath);
     if (importPath.startsWith('.') || (0, utils_js_1.isFilePathAbsolute)(importPath)) {
         if (importPath.startsWith('.')) {
-            (0, utils_js_1.assert)(importPath.startsWith('./') || importPath.startsWith('../'));
+            (0, utils_js_1.assertUsage)(importPath.startsWith('./') || importPath.startsWith('../'), `Invalid relative import path ${picocolors_1.default.code(importPath)} defined by ${importerFilePath.filePathToShowToUser} because it should start with ${picocolors_1.default.code('./')} or ${picocolors_1.default.code('../')}, or use an npm package import instead.`);
         }
-        assertImportPath(filePathAbsoluteFilesystem, pointerImportData, importerFilePath);
+        // Pointer imports are included in virtual files, thus relative imports need to be resolved. (Virtual modules cannot contain relative imports.)
+        assertUsageResolutionSuccess(filePathAbsoluteFilesystem, pointerImportData, importerFilePath);
+        // Pointer imports are included in virtual files, and we need filePathAbsoluteUserRootDir because we didn't find a way to have filesystem absolute import paths in virtual files: https://gist.github.com/brillout/2315231c9a8164f950c64b4b4a7bbd39
+        const errSuffix = `outside of the ${userRootDir} directory which is forbidden: make sure your import paths resolve inside the ${userRootDir} directory, or import from an npm package.`;
         const filePathAbsoluteUserRootDir = (0, getFilePath_js_1.getFilePathAbsoluteUserRootDir)({ filePathAbsoluteFilesystem, userRootDir });
-        // This assert() is guarenteed, see assertUsage() in the onResolve() esbuild hook in transpileAndExecuteFile.ts
-        (0, utils_js_1.assert)(filePathAbsoluteUserRootDir);
-        // Imports are included in virtual files, thus the relative path of imports need to resolved.
-        // ```
-        // [vite] Internal server error: Failed to resolve import "./onPageTransitionHooks" from "virtual:vike:pageConfigValuesAll:client:/pages/index". Does the file exist?
-        // ```
+        if (importPath.startsWith('.')) {
+            (0, utils_js_1.assertUsage)(filePathAbsoluteUserRootDir, `The relative import ${picocolors_1.default.cyan(importPath)} defined by ${importerFilePath.filePathToShowToUser} resolves to ${filePathAbsoluteFilesystem} ${errSuffix}`);
+        }
+        else {
+            (0, utils_js_1.assert)((0, utils_js_1.isFilePathAbsolute)(importPath));
+            (0, utils_js_1.assertUsage)(filePathAbsoluteUserRootDir, `The import path ${importPath} defined by ${importerFilePath.filePathToShowToUser} is ${errSuffix}`);
+        }
+        // Forbid node_modules/ because it's brittle: if node_modules/ lives outside of userRootDir then it crashes.
+        (0, utils_js_1.assertUsage)(!filePathAbsoluteUserRootDir.includes('/node_modules/'), `The import path ${importPath} defined by ${importerFilePath.filePathToShowToUser} resolves to ${filePathAbsoluteFilesystem} inside of node_modules/ which is forbbiden: use an npm package import instead.`);
         filePath = (0, getFilePath_js_1.getFilePathResolved)({ filePathAbsoluteUserRootDir, userRootDir });
     }
     else {
         const importPathAbsolute = importPath;
-        // importPath cannot be a path alias (since esbuild resolves path aliases, see transpileAndExecuteFile.ts)
-        (0, utils_js_1.assertIsNpmPackageImport)(importPathAbsolute);
         if (filePathAbsoluteFilesystem) {
             filePath = (0, getFilePath_js_1.getFilePathResolved)({
                 userRootDir,
@@ -81,14 +84,14 @@ function resolveImportPathWithNode(pointerImportData, importerFilePath) {
     const filePathAbsoluteFilesystem = (0, utils_js_1.requireResolve)(pointerImportData.importPath, cwd);
     return filePathAbsoluteFilesystem;
 }
-function assertImportPath(filePathAbsoluteFilesystem, pointerImportData, importerFilePath) {
+function assertUsageResolutionSuccess(filePathAbsoluteFilesystem, pointerImportData, importerFilePath) {
     const { importPath: importPath, importStringWasGenerated, importString } = pointerImportData;
     const { filePathToShowToUser } = importerFilePath;
     if (!filePathAbsoluteFilesystem) {
-        const importPathString = picocolors_1.default.cyan(`'${importPath}'`);
+        const importPathString = picocolors_1.default.code(`${importPath}`);
         const errIntro = importStringWasGenerated
             ? `The import path ${importPathString} in ${filePathToShowToUser}`
-            : `The import ${picocolors_1.default.cyan(importString)} defined in ${filePathToShowToUser}`;
+            : `The import ${picocolors_1.default.code(importString)} defined by ${filePathToShowToUser}`;
         const errIntro2 = `${errIntro} couldn't be resolved: does ${importPathString}`;
         if (importPath.startsWith('.')) {
             (0, utils_js_1.assert)(importPath.startsWith('./') || importPath.startsWith('../'));
@@ -99,7 +102,7 @@ function assertImportPath(filePathAbsoluteFilesystem, pointerImportData, importe
         }
     }
 }
-function assertFileEnv(filePathAbsoluteFilesystem, importPath, configEnv, configName) {
+function assertUsageFileEnv(filePathAbsoluteFilesystem, importPath, configEnv, configName) {
     let key;
     if (filePathAbsoluteFilesystem) {
         key = filePathAbsoluteFilesystem;
@@ -118,7 +121,7 @@ function assertFileEnv(filePathAbsoluteFilesystem, importPath, configEnv, config
     if (configDifferentEnv) {
         (0, utils_js_1.assertUsage)(false, [
             `${key} defines the value of configs living in different environments:`,
-            ...[configDifferentEnv, { configName, configEnv }].map((c) => `  - config ${picocolors_1.default.cyan(c.configName)} which value lives in environment ${picocolors_1.default.cyan(JSON.stringify(c.configEnv))}`),
+            ...[configDifferentEnv, { configName, configEnv }].map((c) => `  - config ${picocolors_1.default.code(c.configName)} which value lives in environment ${picocolors_1.default.code(JSON.stringify(c.configEnv))}`),
             'Defining config values in the same file is allowed only if they live in the same environment, see https://vike.dev/config#pointer-imports'
         ].join('\n'));
     }

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/{transformFileImports.js → transformPointerImports.js}

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformFileImports = transformFileImports;
+exports.transformPointerImports = transformPointerImports;
 exports.parsePointerImportData = parsePointerImportData;
 exports.isPointerImportData = isPointerImportData;
 // Playground: https://github.com/brillout/acorn-playground
@@ -24,9 +24,8 @@ exports.isPointerImportData = isPointerImportData;
 const acorn_1 = require("acorn");
 const utils_js_1 = require("../../../../utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-// TODO: rename transformFileImports() => transformPointerImports()
-function transformFileImports(code, filePathToShowToUser2, pointerImports, 
-// For ./transformFileImports.spec.ts
+function transformPointerImports(code, filePathToShowToUser2, pointerImports, 
+// For ./transformPointerImports.spec.ts
 skipWarnings) {
     const spliceOperations = [];
     // Performance trick

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

@@ -13,7 +13,7 @@ const path_1 = __importDefault(require("path"));
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const import_1 = require("@brillout/import");
 const utils_js_1 = require("../../../../utils.js");
-const transformFileImports_js_1 = require("./transformFileImports.js");
+const transformPointerImports_js_1 = require("./transformPointerImports.js");
 const getVikeConfig_js_1 = require("../getVikeConfig.js");
 require("source-map-support/register.js");
 const getFilePath_js_1 = require("../../../../shared/getFilePath.js");
@@ -22,7 +22,7 @@ const debug = (0, utils_js_1.createDebugger)('vike:pointer-imports');
 async function transpileAndExecuteFile(filePath, userRootDir, isConfigFile) {
     const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath;
     const fileExtension = getFileExtension(filePathAbsoluteFilesystem);
-    (0, utils_js_1.assertUsage)((0, utils_js_1.isJavaScriptFile)(filePathAbsoluteFilesystem), `${filePathToShowToUserResolved} has file extension .${fileExtension} but a config file can only be a JavaScript/TypeScript file`);
+    (0, utils_js_1.assertUsage)((0, utils_js_1.isPlainJavaScriptFile)(filePathAbsoluteFilesystem), `${filePathToShowToUserResolved} has file extension .${fileExtension} but a config file can only be a JavaScript/TypeScript file`);
     const isHeader = isHeaderFile(filePathAbsoluteFilesystem);
     if (isHeader) {
         (0, utils_js_1.assertWarning)(false, `${picocolors_1.default.cyan('.h.js')} files are deprecated: simply renaming ${filePathToShowToUserResolved} to ${removeHeaderFileExtension(filePathToShowToUserResolved)} is usually enough, although you may occasionally need to use ${picocolors_1.default.cyan("with { type: 'pointer' }")} as explained at https://vike.dev/config#pointer-imports`, { onlyOnce: true });
@@ -50,17 +50,17 @@ async function transpileFile(filePath, transformImports, userRootDir) {
         debug(`code, post esbuild (${filePathToShowToUserResolved})`, code);
     let isImportTransformed = false;
     if (transformImports) {
-        const codeMod = (0, transformFileImports_js_1.transformFileImports)(code, filePathToShowToUserResolved, pointerImports);
+        const codeMod = (0, transformPointerImports_js_1.transformPointerImports)(code, filePathToShowToUserResolved, pointerImports);
         if (codeMod) {
             code = codeMod;
             isImportTransformed = true;
             if (debug.isActivated)
-                debug(`code, post transformImports() (${filePathToShowToUserResolved})`, code);
+                debug(`code, post pointer imports transform (${filePathToShowToUserResolved})`, code);
         }
     }
     if (!isImportTransformed) {
         if (debug.isActivated)
-            debug(`code, no transformImports() (${filePathToShowToUserResolved})`);
+            debug(`code, no pointer imports (${filePathToShowToUserResolved})`);
     }
     return code;
 }
@@ -108,12 +108,12 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
                     opts.pluginData = { [useEsbuildResolver]: true };
                     const resolved = await build.resolve(path, opts);
                     if (resolved.errors.length > 0) {
-                        /* We could do the following to let Node.js throw the error, but we don't because the error shown by esbuild is prettier: the Node.js error refers to the transpiled [build-f7i251e0iwnw]+config.ts.mjs file which isn't that nice, whereas esbuild refers to the source +config.ts file.
+                        /* We could do the following to let Node.js throw the error, but we don't because the error shown by esbuild is prettier: the Node.js error refers to the transpiled [build-f7i251e0iwnw]+config.ts.mjs whereas esbuild refers to the source +config.ts file.
                         pointerImports[args.path] = false
                         return { external: true }
                         */
-                        // Let esbuild throw the error. (It throws a nice & pretty error.)
                         cleanEsbuildErrors(resolved.errors);
+                        // Let esbuild throw the error
                         return resolved;
                     }
                     (0, utils_js_1.assert)(resolved.path);
@@ -121,73 +121,70 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
                     const importPathOriginal = args.path;
                     // Esbuild resolves path aliases.
                     // - Enabling us to use:
-                    //   ```js
-                    //   isNpmPackageImport(str, { cannotBePathAlias: true })
-                    //   assertIsNpmPackageImport()
-                    //   ```
+                    //   - assertIsNpmPackageImport()
+                    //   - isNpmPackageImport(str, { cannotBePathAlias: true })
                     (0, utils_js_1.assertFilePathAbsoluteFilesystem)(importPathResolved);
                     // vike-{react,vue,solid} follow the convention that their config export resolves to a file named +config.js
                     //  - This is temporary, see comment below.
-                    const isVikeExtensionConfigImport = importPathResolved.endsWith('+config.js');
+                    const isVikeExtensionImport = importPathResolved.endsWith('+config.js');
                     const isPointerImport = transformImports === 'all' ||
-                        // .jsx, .vue, .svg, ... => obviously not config code
-                        !(0, utils_js_1.isJavaScriptFile)(importPathResolved) ||
-                        // Import of a Vike extension config => make it a pointer import because we want to show nice error messages (that can display whether a configas been set by the user or by a Vike extension).
-                        //  - We should have Node.js directly load vike-{react,vue,solid} while enforcing Vike extensions to set 'name' in their +config.js file.
+                        // .jsx, .vue, .svg, ... => obviously not config code => pointer import
+                        !(0, utils_js_1.isPlainJavaScriptFile)(importPathResolved) ||
+                        // Import of a Vike extension config => make it a pointer import because we want to show nice error messages (that can display whether a config has been set by the user or by a Vike extension).
+                        //  - TODO/eventually: stop doing this and, instead, let Node.js directly load vike-{react,vue,solid} while enforcing Vike extensions to set 'name' in their +config.js file.
                         //    - vike@0.4.162 already started soft-requiring Vike extensions to set the name config
-                        isVikeExtensionConfigImport ||
-                        // Cannot be resolved by esbuild => take a leap of faith and make it a pointer import.
-                        //  - For example if esbuild cannot resolve a path alias while Vite can.
-                        //    - When tsconfig.js#compilerOptions.paths is set, then esbuild is able to resolve the path alias.
-                        resolved.errors.length > 0;
+                        isVikeExtensionImport;
                     (0, utils_js_1.assertPosixPath)(importPathResolved);
                     const isNodeModules = importPathResolved.includes('/node_modules/');
                     const isExternal = isPointerImport ||
-                        // Performance: npm package imports that aren't pointer imports can be externalized. For example, if Vike eventually adds support for setting Vite configs in the vike.config.js file, then the user may import a Vite plugin in his vike.config.js file. (We could as well let esbuild always transpile /node_modules/ code but it would be useless and would unnecessarily slow down transpilation.)
+                        // Performance: npm package imports can be externalized. (We could as well let esbuild transpile /node_modules/ code but it's useless as /node_modules/ code is already built. It would unnecessarily slow down transpilation.)
                         isNodeModules;
-                    const filePathAbsoluteUserRootDir = (0, getFilePath_js_1.getFilePathAbsoluteUserRootDir)({
-                        filePathAbsoluteFilesystem: importPathResolved,
-                        userRootDir
-                    });
+                    if (!isExternal) {
+                        // User-land config code (i.e. not runtime code) => let esbuild transpile it
+                        (0, utils_js_1.assert)(!isPointerImport && !isNodeModules);
+                        if (debug.isActivated)
+                            debug('onResolved()', { args, resolved, isPointerImport, isExternal });
+                        return resolved;
+                    }
                     let importPathTranspiled;
                     (0, utils_js_1.assertPosixPath)(importPathOriginal);
                     if (importPathOriginal.startsWith('./') || importPathOriginal.startsWith('../')) {
-                        // - We need this assertUsage() because we didn't find a way (yet?) to use filesystem absolute import paths in virtual files.
-                        // - Alternatively, we can again try one of the following for generating the imports of virtual files. (Last time we tried none of it worked.)
-                        //   - ~~~js
-                        //     assert(filePathAbsoluteFilesystem.startsWith('/'))
-                        //     filePath = `/@fs${filePathAbsoluteFilesystem}`
-                        //     ~~~
-                        //   - ~~~js
-                        //     assert(filePathAbsoluteUserRootDir.startsWith('../'))
-                        //     filePathAbsoluteUserRootDir = '/' + filePathAbsoluteUserRootDir
-                        //     ~~~
-                        (0, utils_js_1.assertUsage)(filePathAbsoluteUserRootDir, `Import ${picocolors_1.default.cyan(importPathOriginal)} resolves to ${importPathResolved} outside of ${userRootDir} which is forbidden: make sure your relative import paths resolve inside ${userRootDir}, or import from an npm package.`);
                         importPathTranspiled = importPathResolved;
                     }
                     else {
-                        // importPathOriginal is either:
+                        // `importPathOriginal` is either:
                         //  - Npm package import
                         //  - Path alias
+                        const filePathAbsoluteUserRootDir = (0, getFilePath_js_1.getFilePathAbsoluteUserRootDir)({
+                            filePathAbsoluteFilesystem: importPathResolved,
+                            userRootDir
+                        });
+                        // We assuming that path aliases always resolve inside `userRootDir`.
                         if (filePathAbsoluteUserRootDir && !isNodeModules) {
-                            // importPathOriginal is most likely (always?) a path alias.
+                            // `importPathOriginal` is a path alias.
+                            // - We have to use esbuild's path alias resolution, because:
+                            //   - Vike doesn't resolve path aliases at all.
+                            //   - Node.js doesn't support `tsconfig.js#compilerOptions.paths`.
+                            // - Esbuild path alias resolution seems to be reliable, e.g. it supports `tsconfig.js#compilerOptions.paths`.
                             importPathTranspiled = importPathResolved;
                         }
                         else {
-                            // importPathOriginal is an npm package import. (Assuming path aliases always resolve inside `userRootDir`.)
+                            // `importPathOriginal` is an npm package import.
                             (0, utils_js_1.assertIsNpmPackageImport)(importPathOriginal);
+                            // For less confusing error messages, let the resolution be handled by Vike or Node.js.
                             importPathTranspiled = importPathOriginal;
                         }
                     }
                     if (debug.isActivated)
                         debug('onResolved()', { args, resolved, importPathTranspiled, isPointerImport, isExternal });
-                    if (isExternal) {
-                        pointerImports[importPathTranspiled] = isPointerImport;
-                        return { external: true, path: importPathTranspiled };
-                    }
-                    else {
-                        return resolved;
-                    }
+                    (0, utils_js_1.assert)(isExternal);
+                    (0, utils_js_1.assert)(
+                    // Import of runtime code => handled by Vike
+                    isPointerImport ||
+                        // Import of config code => loaded by Node.js at build-time
+                        isNodeModules);
+                    pointerImports[importPathTranspiled] = isPointerImport;
+                    return { external: true, path: importPathTranspiled };
                 });
             }
         },

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

@@ -243,7 +243,7 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev, crawlWithGit) {
     const importedFilesLoaded = {};
     const { globalVikeConfig, pageConfigGlobal } = await getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded);
     const pageConfigs = await Promise.all((0, utils_js_1.objectEntries)(interfaceFilesByLocationId)
-        .filter(([_pageId, interfaceFiles]) => isDefiningPage(interfaceFiles))
+        .filter(([pageId, interfaceFiles]) => isDefiningPage(interfaceFiles))
         .map(async ([locationId]) => {
         const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesByLocationId, locationId);
         const interfaceFilesRelevantList = Object.values(interfaceFilesRelevant).flat(1);

package/dist/cjs/node/prerender/runPrerender.js

@@ -306,7 +306,7 @@ async function handlePagesWithStaticRoutes(prerenderContext, renderContext, doNo
         (0, utils_js_1.objectAssign)(pageContext, {
             _providedByHook: null,
             routeParams,
-            _pageId: pageId,
+            pageId: pageId,
             _debugRouteMatches: [
                 {
                     pageId,
@@ -469,8 +469,8 @@ async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete)
         const { urlOriginal } = pageContext;
         (0, utils_js_1.assert)(urlOriginal);
         const pageContextFromRoute = await (0, index_js_1.route)(pageContext);
-        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextFromRoute, '_pageId', 'null') || (0, utils_js_1.hasProp)(pageContextFromRoute, '_pageId', 'string'));
-        if (pageContextFromRoute._pageId === null) {
+        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextFromRoute, 'pageId', 'null') || (0, utils_js_1.hasProp)(pageContextFromRoute, 'pageId', 'string'));
+        if (pageContextFromRoute.pageId === null) {
             let hookName;
             let hookFilePath;
             if (pageContext._providedByHook) {
@@ -492,9 +492,9 @@ async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete)
                 return;
             }
         }
-        (0, utils_js_1.assert)(pageContextFromRoute._pageId);
+        (0, utils_js_1.assert)(pageContextFromRoute.pageId);
         (0, utils_js_1.objectAssign)(pageContext, pageContextFromRoute);
-        const { _pageId: pageId } = pageContext;
+        const { pageId: pageId } = pageContext;
         (0, utils_js_1.objectAssign)(pageContext, await (0, loadUserFilesServerSide_js_1.loadUserFilesServerSide)(pageContext));
         let usesClientRouter;
         {

package/dist/cjs/node/runtime/html/injectAssets/getHtmlTags.js

@@ -19,7 +19,7 @@ function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter,
     (0, utils_js_1.assert)([true, false].includes(pageContext._isHtmlOnly));
     const isHtmlOnly = pageContext._isHtmlOnly;
     const { isProduction } = (0, globalContext_js_1.getGlobalContext)();
-    const injectScriptsAt = getInjectScriptsAt(pageContext._pageId, pageContext._pageConfigs);
+    const injectScriptsAt = getInjectScriptsAt(pageContext.pageId, pageContext._pageConfigs);
     const injectFilterEntries = pageAssets
         .filter((asset) => {
         if (asset.isEntry && asset.assetType === 'script') {

package/dist/cjs/node/runtime/html/injectAssets/injectAssets__public.js

@@ -16,7 +16,7 @@ async function injectAssets__public(htmlString, pageContext) {
     (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(pageContext, 'urlPathname', 'string'), errMsg('`pageContext.urlPathname` should be a string'), {
         showStackTrace: true
     });
-    (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(pageContext, '_pageId', 'string'), errMsg('`pageContext._pageId` should be a string'), {
+    (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(pageContext, 'pageId', 'string'), errMsg('`pageContext.pageId` should be a string'), {
         showStackTrace: true
     });
     (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(pageContext, '__getPageAssets'), errMsg('`pageContext.__getPageAssets` is missing'), {

package/dist/cjs/node/runtime/html/serializePageContextClientSide.js

@@ -23,7 +23,7 @@ const PASS_TO_CLIENT = [
     '_abortCaller',
     */
     pageContextInitIsPassedToClient_js_1.pageContextInitIsPassedToClient,
-    '_pageId',
+    'pageId',
     'routeParams',
     'data' // for data() hook
 ];
@@ -100,7 +100,7 @@ function serialize(value, varName) {
 }
 function getPassToClient(pageContext) {
     let passToClient = [...pageContext._passToClient, ...PASS_TO_CLIENT];
-    if ((0, error_page_js_1.isErrorPage)(pageContext._pageId, pageContext._pageConfigs)) {
+    if ((0, error_page_js_1.isErrorPage)(pageContext.pageId, pageContext._pageConfigs)) {
         (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContext, 'is404', 'boolean'));
         (0, addIs404ToPageProps_js_1.addIs404ToPageProps)(pageContext);
         passToClient.push(...PASS_TO_CLIENT_ERROR_PAGE);