vike 0.4.197 → 0.4.198-commit-081c85f

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

@@ -3,7 +3,7 @@ export { resolvePointerImport };
 export { clearFilesEnvMap };
 import pc from '@brillout/picocolors';
 import { assert, assertIsNpmPackageImport, assertPosixPath, assertUsage, deepEqual, isFilePathAbsolute, requireResolve } from '../../../../utils.js';
-import { parsePointerImportData } from './transformFileImports.js';
+import { parsePointerImportData } from './transformPointerImports.js';
 import path from 'path';
 import { getFilePathAbsoluteUserRootDir, getFilePathResolved, getFilePathUnresolved } from '../../../../shared/getFilePath.js';
 const filesEnvMap = new Map();
@@ -16,7 +16,7 @@ function resolvePointerImportOfConfig(configValue, importerFilePath, userRootDir
     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,
@@ -24,33 +24,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)
     assertPosixPath(importPath);
     if (importPath.startsWith('.') || isFilePathAbsolute(importPath)) {
         if (importPath.startsWith('.')) {
-            assert(importPath.startsWith('./') || importPath.startsWith('../'));
+            assertUsage(importPath.startsWith('./') || importPath.startsWith('../'), `Invalid relative import path ${pc.code(importPath)} defined by ${importerFilePath.filePathToShowToUser} because it should start with ${pc.code('./')} or ${pc.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 = getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDir });
-        // This assert() is guarenteed, see assertUsage() in the onResolve() esbuild hook in transpileAndExecuteFile.ts
-        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('.')) {
+            assertUsage(filePathAbsoluteUserRootDir, `The relative import ${pc.cyan(importPath)} defined by ${importerFilePath.filePathToShowToUser} resolves to ${filePathAbsoluteFilesystem} ${errSuffix}`);
+        }
+        else {
+            assert(isFilePathAbsolute(importPath));
+            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.
+        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 = getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir });
     }
     else {
         const importPathAbsolute = importPath;
-        // importPath cannot be a path alias (since esbuild resolves path aliases, see transpileAndExecuteFile.ts)
-        assertIsNpmPackageImport(importPathAbsolute);
         if (filePathAbsoluteFilesystem) {
             filePath = getFilePathResolved({
                 userRootDir,
@@ -76,14 +79,14 @@ function resolveImportPathWithNode(pointerImportData, importerFilePath) {
     const filePathAbsoluteFilesystem = 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 = pc.cyan(`'${importPath}'`);
+        const importPathString = pc.code(`${importPath}`);
         const errIntro = importStringWasGenerated
             ? `The import path ${importPathString} in ${filePathToShowToUser}`
-            : `The import ${pc.cyan(importString)} defined in ${filePathToShowToUser}`;
+            : `The import ${pc.code(importString)} defined by ${filePathToShowToUser}`;
         const errIntro2 = `${errIntro} couldn't be resolved: does ${importPathString}`;
         if (importPath.startsWith('.')) {
             assert(importPath.startsWith('./') || importPath.startsWith('../'));
@@ -94,7 +97,7 @@ function assertImportPath(filePathAbsoluteFilesystem, pointerImportData, importe
         }
     }
 }
-function assertFileEnv(filePathAbsoluteFilesystem, importPath, configEnv, configName) {
+function assertUsageFileEnv(filePathAbsoluteFilesystem, importPath, configEnv, configName) {
     let key;
     if (filePathAbsoluteFilesystem) {
         key = filePathAbsoluteFilesystem;
@@ -113,7 +116,7 @@ function assertFileEnv(filePathAbsoluteFilesystem, importPath, configEnv, config
     if (configDifferentEnv) {
         assertUsage(false, [
             `${key} defines the value of configs living in different environments:`,
-            ...[configDifferentEnv, { configName, configEnv }].map((c) => `  - config ${pc.cyan(c.configName)} which value lives in environment ${pc.cyan(JSON.stringify(c.configEnv))}`),
+            ...[configDifferentEnv, { configName, configEnv }].map((c) => `  - config ${pc.code(c.configName)} which value lives in environment ${pc.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/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/{transformFileImports.d.ts → transformPointerImports.d.ts}

@@ -1,8 +1,8 @@
-export { transformFileImports };
+export { transformPointerImports };
 export { parsePointerImportData };
 export { isPointerImportData };
 export type { PointerImportData };
-declare function transformFileImports(code: string, filePathToShowToUser2: string, pointerImports: Record<string, boolean> | 'all', skipWarnings?: true): string | null;
+declare function transformPointerImports(code: string, filePathToShowToUser2: string, pointerImports: Record<string, boolean> | 'all', skipWarnings?: true): string | null;
 /**
  * Data Structure for [pointer imports](https://vike.dev/config#pointer-imports):
  *   `import { someExport as someImport } from './some-file'`

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

@@ -1,4 +1,4 @@
-export { transformFileImports };
+export { transformPointerImports };
 export { parsePointerImportData };
 export { isPointerImportData };
 // Playground: https://github.com/brillout/acorn-playground
@@ -19,9 +19,8 @@ export { isPointerImportData };
 import { parse } from 'acorn';
 import { assert, assertUsage, assertWarning, styleFileRE } from '../../../../utils.js';
 import pc from '@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/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transpileAndExecuteFile.js

@@ -7,8 +7,8 @@ import fs from 'fs';
 import path from 'path';
 import pc from '@brillout/picocolors';
 import { import_ } from '@brillout/import';
-import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, assertWarning, isObject, toPosixPath, assertUsage, isJavaScriptFile, createDebugger, assertFilePathAbsoluteFilesystem, assertIsNpmPackageImport } from '../../../../utils.js';
-import { transformFileImports } from './transformFileImports.js';
+import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, assertWarning, isObject, toPosixPath, assertUsage, isPlainJavaScriptFile, createDebugger, assertFilePathAbsoluteFilesystem, assertIsNpmPackageImport } from '../../../../utils.js';
+import { transformPointerImports } from './transformPointerImports.js';
 import { vikeConfigDependencies } from '../getVikeConfig.js';
 import 'source-map-support/register.js';
 import { getFilePathAbsoluteUserRootDir } from '../../../../shared/getFilePath.js';
@@ -17,7 +17,7 @@ const debug = createDebugger('vike:pointer-imports');
 async function transpileAndExecuteFile(filePath, userRootDir, isConfigFile) {
     const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath;
     const fileExtension = getFileExtension(filePathAbsoluteFilesystem);
-    assertUsage(isJavaScriptFile(filePathAbsoluteFilesystem), `${filePathToShowToUserResolved} has file extension .${fileExtension} but a config file can only be a JavaScript/TypeScript file`);
+    assertUsage(isPlainJavaScriptFile(filePathAbsoluteFilesystem), `${filePathToShowToUserResolved} has file extension .${fileExtension} but a config file can only be a JavaScript/TypeScript file`);
     const isHeader = isHeaderFile(filePathAbsoluteFilesystem);
     if (isHeader) {
         assertWarning(false, `${pc.cyan('.h.js')} files are deprecated: simply renaming ${filePathToShowToUserResolved} to ${removeHeaderFileExtension(filePathToShowToUserResolved)} is usually enough, although you may occasionally need to use ${pc.cyan("with { type: 'pointer' }")} as explained at https://vike.dev/config#pointer-imports`, { onlyOnce: true });
@@ -45,17 +45,17 @@ async function transpileFile(filePath, transformImports, userRootDir) {
         debug(`code, post esbuild (${filePathToShowToUserResolved})`, code);
     let isImportTransformed = false;
     if (transformImports) {
-        const codeMod = transformFileImports(code, filePathToShowToUserResolved, pointerImports);
+        const codeMod = 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;
 }
@@ -103,12 +103,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;
                     }
                     assert(resolved.path);
@@ -116,73 +116,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 })
                     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
-                        !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
+                        !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;
                     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 = getFilePathAbsoluteUserRootDir({
-                        filePathAbsoluteFilesystem: importPathResolved,
-                        userRootDir
-                    });
+                    if (!isExternal) {
+                        // User-land config code (i.e. not runtime code) => let esbuild transpile it
+                        assert(!isPointerImport && !isNodeModules);
+                        if (debug.isActivated)
+                            debug('onResolved()', { args, resolved, isPointerImport, isExternal });
+                        return resolved;
+                    }
                     let importPathTranspiled;
                     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
-                        //     ~~~
-                        assertUsage(filePathAbsoluteUserRootDir, `Import ${pc.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 = 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.
                             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;
-                    }
+                    assert(isExternal);
+                    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/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js

@@ -832,6 +832,9 @@ function assertNoUnexpectedPlusSign(filePath: string, fileName: string) {
 }
 */
 function handleUnknownConfig(configName, configNames, filePathToShowToUser) {
+    const configNameColored = pc.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 = {
@@ -848,14 +851,16 @@ function handleUnknownConfig(configName, configNames, filePathToShowToUser) {
         if (configName in knownVikeExntensionConfigs) {
             const requiredVikeExtension = knownVikeExntensionConfigs[configName];
             assertUsage(false, [
-                `${filePathToShowToUser} uses the config ${pc.cyan(configName)} (https://vike.dev/${configName})`,
-                `which requires the Vike extension ${requiredVikeExtension.map((e) => pc.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) => pc.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 ${pc.cyan('meta')} (https://vike.dev/meta).`
             ].join(' '));
         }
     }
-    let errMsg = `${filePathToShowToUser} sets an unknown config ${pc.cyan(configName)}`;
+    // Similarity hint
     let configNameSimilar = null;
     if (configName === 'page') {
         configNameSimilar = 'Page';
@@ -865,11 +870,15 @@ function handleUnknownConfig(configName, configNames, filePathToShowToUser) {
     }
     if (configNameSimilar) {
         assert(configNameSimilar !== configName);
-        errMsg += `, did you mean to set ${pc.cyan(configNameSimilar)} instead?`;
+        errMsg += ` Did you mean to set ${pc.cyan(configNameSimilar)} instead?`;
         if (configName === 'page') {
-            errMsg += ` (The name of the config ${pc.cyan('Page')} starts with a capital letter ${pc.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 ${pc.cyan('Page')} starts with a capital letter ${pc.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 ${pc.cyan('meta')} (https://vike.dev/meta), and also make sure the meta configuration applies to ${filePathToShowToUser} (see https://vike.dev/config#inheritance).`;
+    }
     assertUsage(false, errMsg);
 }
 function determineRouteFilesystem(locationId, configValueSources) {

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

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

package/dist/esm/shared/page-configs/Config.d.ts

@@ -31,13 +31,13 @@ export type { OnRenderHtmlSync };
 export type { RouteAsync };
 export type { RouteSync };
 export type { KeepScrollPosition };
+import type { PrefetchSetting, PrefetchStaticAssets } from '../../client/client-routing-runtime/prefetch/PrefetchSetting.js';
 import type { ConfigDefinition } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
 import type { DocumentHtml } from '../../node/runtime/html/renderHtml.js';
 import type { ConfigVikeUserProvided } from '../ConfigVike.js';
 import type { Vike, VikePackages } from '../VikeNamespace.js';
 import type { HooksTimeoutProvidedByUser } from '../hooks/getHook.js';
 import type { PageContextClient, PageContextServer } from '../types.js';
-import type { PrefetchStaticAssets } from '../types/PrefetchStaticAssets.js';
 type HookName = HookNamePage | HookNameGlobal | HookNameOldDesign;
 type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'data';
 type HookNameGlobal = 'onBeforePrerender' | 'onBeforeRoute' | 'onPrerenderStart';
@@ -344,6 +344,15 @@ type ConfigBuiltIn = {
      * https://vike.dev/meta
      */
     meta?: ConfigMeta | ImportString;
+    /**
+     * @experimental: DON'T USE: the API *will* have breaking changes upon any minor version release.
+     *
+     * Prefetch pages/links.
+     *
+     * https://vike.dev/prefetch
+     */
+    prefetch?: PrefetchSetting | ImportString;
+    /** @deprecated Use `prefetch` setting (https://vike.dev/prefetch) instead.  */
     /** Prefetch links.
      *
      * https://vike.dev/prefetchStaticAssets

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

@@ -2,7 +2,7 @@ export { serializeConfigValues };
 import { assertIsNotProductionRuntime } from '../../../utils/assertIsNotProductionRuntime.js';
 import { assert, assertUsage, getPropAccessNotation } from '../../../node/plugin/utils.js';
 import { addImportStatement } from '../../../node/plugin/plugins/importUserCode/addImportStatement.js';
-import { parsePointerImportData } from '../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transformFileImports.js';
+import { parsePointerImportData } from '../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transformPointerImports.js';
 import { getConfigValueFilePathToShowToUser } from '../helpers.js';
 import { stringify } from '@brillout/json-serializer/stringify';
 import pc from '@brillout/picocolors';

package/dist/esm/shared/types.d.ts

@@ -105,7 +105,7 @@ type PageContextBuiltInCommon<Data> = {
     /**
      * Error that occured while rendering.
      *
-     * https://vike.dev/errors
+     * https://vike.dev/error-tracking
      */
     errorWhileRendering?: unknown;
     /**

package/dist/esm/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.197";
+export declare const PROJECT_VERSION: "0.4.198-commit-081c85f";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.197';
+export const PROJECT_VERSION = '0.4.198-commit-081c85f';

package/dist/esm/utils/isNpmPackage.d.ts

@@ -1,4 +1,5 @@
 export { isNpmPackageImport };
+export { isNpmPackageImport_unreliable };
 export { assertIsNpmPackageImport };
 export { isValidPathAlias };
 export { parse };
@@ -6,6 +7,7 @@ export { isDistinguishable };
 declare function isNpmPackageImport(str: string, { cannotBePathAlias }: {
     cannotBePathAlias: true;
 }): boolean;
+declare function isNpmPackageImport_unreliable(str: string): boolean;
 declare function assertIsNpmPackageImport(str: string): void;
 declare function isValidPathAlias(alias: string): boolean;
 declare function isDistinguishable(alias: string): boolean;

package/dist/esm/utils/isNpmPackage.js

@@ -1,4 +1,5 @@
 export { isNpmPackageImport };
+export { isNpmPackageImport_unreliable };
 export { assertIsNpmPackageImport };
 export { isValidPathAlias };
 /* Currently not used
@@ -15,6 +16,9 @@ assertIsNotBrowser();
 function isNpmPackageImport(str, { cannotBePathAlias }) {
     // We cannot distinguish path alises that look like npm package imports
     assert(cannotBePathAlias);
+    return isNpmPackageImport_unreliable(str);
+}
+function isNpmPackageImport_unreliable(str) {
     const res = parse(str);
     return res !== null;
 }

package/dist/esm/utils/isScriptFile.d.ts

@@ -1,10 +1,10 @@
 export { isScriptFile };
-export { isJavaScriptFile };
+export { isPlainJavaScriptFile };
 export { isTemplateFile };
 export { scriptFileExtensions };
 export { scriptFileExtensionList };
 declare const scriptFileExtensionList: readonly [...string[], "jsx", "tsx", "cjsx", "ctsx", "mjsx", "mtsx", "vue", "svelte", "marko", "md", "mdx"];
 declare const scriptFileExtensions: string;
 declare function isScriptFile(filePath: string): boolean;
-declare function isJavaScriptFile(filePath: string): boolean;
+declare function isPlainJavaScriptFile(filePath: string): boolean;
 declare function isTemplateFile(filePath: string): boolean;

package/dist/esm/utils/isScriptFile.js

@@ -1,5 +1,5 @@
 export { isScriptFile };
-export { isJavaScriptFile };
+export { isPlainJavaScriptFile };
 export { isTemplateFile };
 export { scriptFileExtensions };
 export { scriptFileExtensionList };
@@ -46,11 +46,11 @@ const scriptFileExtensionList = [...extJavaScript, ...extJsx, ...extTemplates];
 const scriptFileExtensions = '(' + scriptFileExtensionList.join('|') + ')';
 function isScriptFile(filePath) {
     const yes = scriptFileExtensionList.some((ext) => filePath.endsWith('.' + ext));
-    if (isJavaScriptFile(filePath))
+    if (isPlainJavaScriptFile(filePath))
         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));
     assert(yes1 === yes2);

package/dist/esm/utils/parseUrl.d.ts

@@ -1,10 +1,10 @@
 export { parseUrl };
-export { assertUsageUrlPathname };
 export { assertUsageUrlPathnameAbsolute };
 export { assertUsageUrlRedirectTarget };
 export { isUrl };
 export { isUri };
 export { isUrlRedirectTarget };
+export { isUrlPathnameRelative };
 export { isUrlExternal };
 export { isBaseServer };
 export { assertUrlComponents };
@@ -50,8 +50,8 @@ declare function assertUrlComponents(url: string, origin: string | null, pathnam
 declare function createUrlFromComponents(origin: string | null, pathname: string, search: string | null, hash: string | null): string;
 declare function isUrl(url: string): boolean;
 declare function isUrlRedirectTarget(url: string): boolean;
+declare function isUrlPathnameRelative(url: string): boolean;
 declare function isUrlExternal(url: string): boolean;
 declare function isUri(uri: string): boolean;
-declare function assertUsageUrlPathname(url: string, errPrefix: string): void;
 declare function assertUsageUrlPathnameAbsolute(url: string, errPrefix: string): void;
 declare function assertUsageUrlRedirectTarget(url: string, errPrefix: string, isUnresolved?: true): void;

package/dist/esm/utils/parseUrl.js

@@ -3,12 +3,12 @@
 //  - It doesn't support the tauri:// protocol
 // Unit tests at ./parseUrl.spec.ts
 export { parseUrl };
-export { assertUsageUrlPathname };
 export { assertUsageUrlPathnameAbsolute };
 export { assertUsageUrlRedirectTarget };
 export { isUrl };
 export { isUri };
 export { isUrlRedirectTarget };
+export { isUrlPathnameRelative };
 export { isUrlExternal };
 export { isBaseServer };
 export { assertUrlComponents };
@@ -293,16 +293,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 ${pc.string(url)} but it should start with ${pc.string('/')}`;
@@ -316,10 +313,5 @@ function assertUsageUrl(url, errPrefix, { allowRelative, isRedirectTarget } = {}
             errMsg += `, or be ${pc.string('*')}`;
         }
     }
-    if (allowRelative) {
-        if (isUrlPathnameRelative(url))
-            return;
-        errMsg += ', or be a relative URL';
-    }
     assertUsage(false, errMsg);
 }

package/dist/esm/utils/projectInfo.d.ts

@@ -1,4 +1,4 @@
 export declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.197";
+    projectVersion: "0.4.198-commit-081c85f";
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.197",
+  "version": "0.4.198-commit-081c85f",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {

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

@@ -1,2 +0,0 @@
-export { installClientRouter };
-declare function installClientRouter(): Promise<void>;

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

@@ -1,2 +0,0 @@
-export { onLinkClick };
-declare function onLinkClick(): void;

package/dist/esm/client/client-routing-runtime/prefetch/alreadyPrefetched.d.ts

@@ -1,4 +0,0 @@
-export { isAlreadyPrefetched };
-export { markAsAlreadyPrefetched };
-declare function isAlreadyPrefetched(url: string): boolean;
-declare function markAsAlreadyPrefetched(url: string): void;

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

@@ -1,16 +0,0 @@
-export { isAlreadyPrefetched };
-export { markAsAlreadyPrefetched };
-import { parseUrl } from '../utils.js';
-const linkAlreadyPrefetched = new Map();
-function isAlreadyPrefetched(url) {
-    const urlPathname = getUrlPathname(url);
-    return linkAlreadyPrefetched.has(urlPathname);
-}
-function markAsAlreadyPrefetched(url) {
-    const urlPathname = getUrlPathname(url);
-    linkAlreadyPrefetched.set(urlPathname, true);
-}
-function getUrlPathname(url) {
-    const urlPathname = parseUrl(url, '/').pathname;
-    return urlPathname;
-}