vike 0.4.197 → 0.4.198-commit-081c85f

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/node/plugin/plugins/fileEnv.js

@@ -22,6 +22,9 @@ function fileEnv() {
                 return;
             if (skip(id))
                 return;
+            // For `.vue` files: https://github.com/vikejs/vike/issues/1912#issuecomment-2394981475
+            if (id.endsWith('?direct'))
+                id = id.slice(0, -1 * '?direct'.length);
             const moduleInfo = viteDevServer.moduleGraph.getModuleById(id);
             (0, utils_js_1.assert)(moduleInfo);
             const importers = Array.from(moduleInfo.importers)

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: {
@@ -152,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

@@ -838,6 +838,9 @@ function assertNoUnexpectedPlusSign(filePath: string, fileName: string) {
 }
 */
 function handleUnknownConfig(configName, configNames, filePathToShowToUser) {
+    const configNameColored = picocolors_1.default.cyan(configName);
+    let errMsg = `${filePathToShowToUser} sets an unknown config ${configNameColored}.`;
+    // vike-{react,vue,solid} hint
     {
         const ui = ['vike-react', 'vike-vue', 'vike-solid'];
         const knownVikeExntensionConfigs = {
@@ -854,14 +857,16 @@ function handleUnknownConfig(configName, configNames, filePathToShowToUser) {
         if (configName in knownVikeExntensionConfigs) {
             const requiredVikeExtension = knownVikeExntensionConfigs[configName];
             (0, utils_js_1.assertUsage)(false, [
-                `${filePathToShowToUser} uses the config ${picocolors_1.default.cyan(configName)} (https://vike.dev/${configName})`,
-                `which requires the Vike extension ${requiredVikeExtension.map((e) => picocolors_1.default.bold(e)).join('/')}.`,
-                `Make sure to install the Vike extension,`,
-                `and make sure it applies to ${filePathToShowToUser} as explained at https://vike.dev/extends#inheritance.`
+                errMsg,
+                `If you want to use the configuration documented at https://vike.dev/${configName} then make sure to install the Vike extension ${requiredVikeExtension
+                    .map((e) => picocolors_1.default.bold(e))
+                    .join('/')}.`,
+                `Also make sure it applies to ${filePathToShowToUser} (see https://vike.dev/extends#inheritance).`,
+                `Alternatively, if you don't want to use the aforementioned Vike extension, define it yourself by using ${picocolors_1.default.cyan('meta')} (https://vike.dev/meta).`
             ].join(' '));
         }
     }
-    let errMsg = `${filePathToShowToUser} sets an unknown config ${picocolors_1.default.cyan(configName)}`;
+    // Similarity hint
     let configNameSimilar = null;
     if (configName === 'page') {
         configNameSimilar = 'Page';
@@ -871,11 +876,15 @@ function handleUnknownConfig(configName, configNames, filePathToShowToUser) {
     }
     if (configNameSimilar) {
         (0, utils_js_1.assert)(configNameSimilar !== configName);
-        errMsg += `, did you mean to set ${picocolors_1.default.cyan(configNameSimilar)} instead?`;
+        errMsg += ` Did you mean to set ${picocolors_1.default.cyan(configNameSimilar)} instead?`;
         if (configName === 'page') {
-            errMsg += ` (The name of the config ${picocolors_1.default.cyan('Page')} starts with a capital letter ${picocolors_1.default.cyan('P')} because it usually defines a UI component: a ubiquitous JavaScript convention is to start the name of UI components with a capital letter.)`;
+            errMsg += ` (The name of the config ${picocolors_1.default.cyan('Page')} starts with a capital letter ${picocolors_1.default.cyan('P')} because it defines a UI component: a ubiquitous JavaScript convention is that the name of UI components start with a capital letter.)`;
         }
     }
+    // `meta` hint
+    if (!configNameSimilar) {
+        errMsg += ` Make sure to define ${configNameColored} by using ${picocolors_1.default.cyan('meta')} (https://vike.dev/meta), and also make sure the meta configuration applies to ${filePathToShowToUser} (see https://vike.dev/config#inheritance).`;
+    }
     (0, utils_js_1.assertUsage)(false, errMsg);
 }
 function determineRouteFilesystem(locationId, configValueSources) {

package/dist/cjs/node/plugin/shared/loggerNotProd.js

@@ -185,7 +185,7 @@ function logErrorDebugNote() {
             return;
         store.errorDebugNoteAlreadyShown = true;
     }
-    const msg = picocolors_1.default.dim((0, utils_js_1.formatHintLog)("Error isn't helpful? See https://vike.dev/errors#verbose"));
+    const msg = picocolors_1.default.dim((0, utils_js_1.formatHintLog)("Error isn't helpful? See https://vike.dev/debug#verbose-errors"));
     (0, log_js_1.logDirectly)(msg, 'error');
 }
 function getCategory(httpRequestId = null) {

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

@@ -7,7 +7,7 @@ exports.serializeConfigValues = serializeConfigValues;
 const assertIsNotProductionRuntime_js_1 = require("../../../utils/assertIsNotProductionRuntime.js");
 const utils_js_1 = require("../../../node/plugin/utils.js");
 const addImportStatement_js_1 = require("../../../node/plugin/plugins/importUserCode/addImportStatement.js");
-const transformFileImports_js_1 = require("../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transformFileImports.js");
+const transformPointerImports_js_1 = require("../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transformPointerImports.js");
 const helpers_js_1 = require("../helpers.js");
 const stringify_1 = require("@brillout/json-serializer/stringify");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
@@ -164,7 +164,7 @@ function valueToJson(value, configName, definedAtData, importStatements) {
             //   - https://github.com/vikejs/vike-react/pull/113
             replacer(_, value) {
                 if (typeof value === 'string') {
-                    const importData = (0, transformFileImports_js_1.parsePointerImportData)(value);
+                    const importData = (0, transformPointerImports_js_1.parsePointerImportData)(value);
                     if (importData) {
                         const { importName } = (0, addImportStatement_js_1.addImportStatement)(importStatements, importData.importPath, importData.exportName);
                         const replacement = [REPLACE_ME_BEFORE, importName, REPLACE_ME_AFTER].join('');

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.197';
+exports.PROJECT_VERSION = '0.4.198-commit-081c85f';

package/dist/cjs/utils/isNpmPackage.js

@@ -1,6 +1,7 @@
 "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;
@@ -11,6 +12,9 @@ const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
 function isNpmPackageImport(str, { cannotBePathAlias }) {
     // We cannot distinguish path alises that look like npm package imports
     (0, assert_js_1.assert)(cannotBePathAlias);
+    return isNpmPackageImport_unreliable(str);
+}
+function isNpmPackageImport_unreliable(str) {
     const res = parse(str);
     return res !== null;
 }

package/dist/cjs/utils/isScriptFile.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scriptFileExtensionList = exports.scriptFileExtensions = void 0;
 exports.isScriptFile = isScriptFile;
-exports.isJavaScriptFile = isJavaScriptFile;
+exports.isPlainJavaScriptFile = isPlainJavaScriptFile;
 exports.isTemplateFile = isTemplateFile;
 const assert_js_1 = require("./assert.js");
 // We can't use a RegExp:
@@ -49,11 +49,11 @@ const scriptFileExtensions = '(' + scriptFileExtensionList.join('|') + ')';
 exports.scriptFileExtensions = scriptFileExtensions;
 function isScriptFile(filePath) {
     const yes = scriptFileExtensionList.some((ext) => filePath.endsWith('.' + ext));
-    if (isJavaScriptFile(filePath))
+    if (isPlainJavaScriptFile(filePath))
         (0, assert_js_1.assert)(yes);
     return yes;
 }
-function isJavaScriptFile(filePath) {
+function isPlainJavaScriptFile(filePath) {
     const yes1 = /\.(c|m)?(j|t)s$/.test(filePath);
     const yes2 = extJavaScript.some((ext) => filePath.endsWith('.' + ext));
     (0, assert_js_1.assert)(yes1 === yes2);

package/dist/cjs/utils/parseUrl.js

@@ -7,12 +7,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseUrl = parseUrl;
-exports.assertUsageUrlPathname = assertUsageUrlPathname;
 exports.assertUsageUrlPathnameAbsolute = assertUsageUrlPathnameAbsolute;
 exports.assertUsageUrlRedirectTarget = assertUsageUrlRedirectTarget;
 exports.isUrl = isUrl;
 exports.isUri = isUri;
 exports.isUrlRedirectTarget = isUrlRedirectTarget;
+exports.isUrlPathnameRelative = isUrlPathnameRelative;
 exports.isUrlExternal = isUrlExternal;
 exports.isBaseServer = isBaseServer;
 exports.assertUrlComponents = assertUrlComponents;
@@ -297,16 +297,13 @@ function isUri(uri) {
     const { protocol } = parseProtocol(uri);
     return !!protocol && !isUrlProtocol(uri);
 }
-function assertUsageUrlPathname(url, errPrefix) {
-    assertUsageUrl(url, errPrefix, { allowRelative: true });
-}
 function assertUsageUrlPathnameAbsolute(url, errPrefix) {
     assertUsageUrl(url, errPrefix);
 }
 function assertUsageUrlRedirectTarget(url, errPrefix, isUnresolved) {
     assertUsageUrl(url, errPrefix, { isRedirectTarget: isUnresolved ? 'unresolved' : true });
 }
-function assertUsageUrl(url, errPrefix, { allowRelative, isRedirectTarget } = {}) {
+function assertUsageUrl(url, errPrefix, { isRedirectTarget } = {}) {
     if (url.startsWith('/'))
         return;
     let errMsg = `${errPrefix} is ${picocolors_1.default.string(url)} but it should start with ${picocolors_1.default.string('/')}`;
@@ -320,10 +317,5 @@ function assertUsageUrl(url, errPrefix, { allowRelative, isRedirectTarget } = {}
             errMsg += `, or be ${picocolors_1.default.string('*')}`;
         }
     }
-    if (allowRelative) {
-        if (isUrlPathnameRelative(url))
-            return;
-        errMsg += ', or be a relative URL';
-    }
     (0, assert_js_1.assertUsage)(false, errMsg);
 }

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

@@ -1,7 +1,7 @@
 import { assertClientRouting } from '../../utils/assertRoutingType.js';
 assertClientRouting();
 import './pageFiles';
-import { installClientRouter } from './installClientRouter.js';
+import { initClientRouter } from './initClientRouter.js';
 import { assertSingleInstance_onClientEntryClientRouting } from './utils.js';
 import { removeFoucBuster } from '../shared/removeFoucBuster.js';
 // @ts-ignore Since dist/cjs/client/ is never used, we can ignore this error.
@@ -9,4 +9,4 @@ const isProd = import.meta.env.PROD;
 assertSingleInstance_onClientEntryClientRouting(isProd);
 if (import.meta.env.DEV)
     removeFoucBuster();
-installClientRouter();
+initClientRouter();

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

@@ -0,0 +1,8 @@
+export { setPageContextCurrent };
+export { getPageContextCurrent };
+import type { PageContextExports } from '../../shared/getPageFiles.js';
+type PageContextCurrent = PageContextExports & {
+    urlPathname: string;
+};
+declare function getPageContextCurrent(): null | PageContextCurrent;
+declare function setPageContextCurrent(pageContextCurrent: PageContextCurrent): void;

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

@@ -0,0 +1,13 @@
+export { setPageContextCurrent };
+export { getPageContextCurrent };
+import { getGlobalObject } from './utils.js';
+const globalObject = getGlobalObject('getPageContextCurrent.ts', {
+    pageContextCurrent: null
+});
+function getPageContextCurrent() {
+    const { pageContextCurrent } = globalObject;
+    return pageContextCurrent;
+}
+function setPageContextCurrent(pageContextCurrent) {
+    globalObject.pageContextCurrent = pageContextCurrent;
+}