vike 0.4.167-commit-4996ef0 → 0.4.167-commit-cfadd0a

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

@@ -82,95 +82,98 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
         // Esbuild still sometimes removes unused imports because of TypeScript: https://github.com/evanw/esbuild/issues/3034
         treeShaking: false,
         minify: false,
-        metafile: true,
-        bundle: true
+        metafile: transformImports !== 'all',
+        bundle: transformImports !== 'all'
     };
-    let pointerImports = {};
-    options.plugins = [
-        // Determine whether an import should be:
-        //  - A pointer import
-        //  - Externalized
-        {
-            name: 'vike-esbuild-plugin',
-            setup(build) {
-                // https://github.com/evanw/esbuild/issues/3095#issuecomment-1546916366
-                const useEsbuildResolver = 'useEsbuildResolver';
-                // https://github.com/brillout/esbuild-playground
-                build.onResolve({ filter: /.*/ }, async (args) => {
-                    if (args.kind !== 'import-statement')
-                        return;
-                    if (args.pluginData?.[useEsbuildResolver])
-                        return;
-                    const { path, ...opts } = args;
-                    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.
-                        pointerImports[args.path] = false
-                        return { external: true }
-                        */
-                        // Let esbuild throw the error. (It throws a nice & pretty error.)
-                        return resolved;
-                    }
-                    (0, utils_js_1.assert)(resolved.path);
-                    resolved.path = (0, utils_js_1.toPosixPath)(resolved.path);
-                    // 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 = resolved.path.endsWith('+config.js');
-                    const isPointerImport = transformImports === 'all' ||
+    let pointerImports;
+    if (transformImports === 'all') {
+        pointerImports = 'all';
+        options.packages = 'external';
+    }
+    else {
+        const pointerImports_ = (pointerImports = {});
+        options.plugins = [
+            // Determine whether an import should be:
+            //  - A pointer import
+            //  - Externalized
+            {
+                name: 'vike-esbuild-plugin',
+                setup(build) {
+                    // https://github.com/evanw/esbuild/issues/3095#issuecomment-1546916366
+                    const useEsbuildResolver = 'useEsbuildResolver';
+                    // https://github.com/brillout/esbuild-playground
+                    build.onResolve({ filter: /.*/ }, async (args) => {
+                        if (args.kind !== 'import-statement')
+                            return;
+                        if (args.pluginData?.[useEsbuildResolver])
+                            return;
+                        const { path, ...opts } = args;
+                        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.
+                            pointerImports_[args.path] = false
+                            return { external: true }
+                            */
+                            // Let esbuild throw the error. (It throws a nice & pretty error.)
+                            return resolved;
+                        }
+                        (0, utils_js_1.assert)(resolved.path);
+                        resolved.path = (0, utils_js_1.toPosixPath)(resolved.path);
+                        // 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 = resolved.path.endsWith('+config.js');
+                        const isPointerImport = 
                         // .jsx, .vue, .svg, ... => obviously not config code
                         !(0, utils_js_1.isJavaScriptFile)(resolved.path) ||
-                        // 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.
-                        //    - 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;
-                    pointerImports[resolved.path] = isPointerImport;
-                    (0, utils_js_1.assertPosixPath)(resolved.path);
-                    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.)
-                        resolved.path.includes('/node_modules/');
-                    if (debug.isActivated)
-                        debug('onResolved()', { args, resolved, isPointerImport, isExternal });
-                    // We need esbuild to resolve path aliases so that we can use:
-                    //   isNpmPackageImport(str, { cannotBePathAlias: true })
-                    //   assertIsNpmPackageImport()
-                    (0, utils_js_1.assertPathIsFilesystemAbsolute)(resolved.path);
-                    if (isExternal) {
-                        return { external: true, path: resolved.path };
-                    }
-                    else {
-                        return resolved;
-                    }
-                });
-            }
-        },
-        // Track dependencies
-        {
-            name: 'vike:dependency-tracker',
-            setup(b) {
-                b.onLoad({ filter: /./ }, (args) => {
-                    // We collect the dependency `args.path` in case the bulid fails (upon build error => error is thrown => no metafile)
-                    let { path } = args;
-                    path = (0, utils_js_1.toPosixPath)(path);
-                    getVikeConfig_js_1.vikeConfigDependencies.add(path);
-                    return undefined;
-                });
-                /* To exhaustively collect all dependencies upon build failure, we would also need to use onResolve().
-                 *  - Because onLoad() isn't call if the config dependency can't be resolved.
-                 *  - For example, the following breaks auto-reload (the config is stuck in its error state and the user needs to touch the importer for the config to reload):
-                 *    ```bash
-                 *    mv ./some-config-dependency.js /tmp/ && mv /tmp/some-config-dependency.js .
-                 *    ```
-                 *  - But implementing a fix is complex and isn't worth it.
-                b.onResolve(...)
-                */
+                            // 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.
+                            //    - 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;
+                        pointerImports_[resolved.path] = isPointerImport;
+                        (0, utils_js_1.assertPosixPath)(resolved.path);
+                        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.)
+                            resolved.path.includes('/node_modules/');
+                        if (debug.isActivated)
+                            debug('onResolved()', { args, resolved, isPointerImport, isExternal });
+                        if (isExternal) {
+                            return { external: true, path: resolved.path };
+                        }
+                        else {
+                            return resolved;
+                        }
+                    });
+                }
+            },
+            // Track dependencies
+            {
+                name: 'vike:dependency-tracker',
+                setup(b) {
+                    b.onLoad({ filter: /./ }, (args) => {
+                        // We collect the dependency `args.path` in case the bulid fails (upon build error => error is thrown => no metafile)
+                        let { path } = args;
+                        path = (0, utils_js_1.toPosixPath)(path);
+                        getVikeConfig_js_1.vikeConfigDependencies.add(path);
+                        return undefined;
+                    });
+                    /* To exhaustively collect all dependencies upon build failure, we would also need to use onResolve().
+                     *  - Because onLoad() isn't call if the config dependency can't be resolved.
+                     *  - For example, the following breaks auto-reload (the config is stuck in its error state and the user needs to touch the importer for the config to reload):
+                     *    ```bash
+                     *    mv ./some-config-dependency.js /tmp/ && mv /tmp/some-config-dependency.js .
+                     *    ```
+                     *  - But implementing a fix is complex and isn't worth it.
+                    b.onResolve(...)
+                    */
+                }
             }
-        }
-    ];
+        ];
+    }
     let result;
     try {
         result = await (0, esbuild_1.build)(options);
@@ -180,13 +183,15 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
         throw err;
     }
     // Track dependencies
-    (0, utils_js_1.assert)(result.metafile);
-    Object.keys(result.metafile.inputs).forEach((filePathRelative) => {
-        filePathRelative = (0, utils_js_1.toPosixPath)(filePathRelative);
-        (0, utils_js_1.assertPosixPath)(userRootDir);
-        const filePathAbsoluteFilesystem = path_1.default.posix.join(userRootDir, filePathRelative);
-        getVikeConfig_js_1.vikeConfigDependencies.add(filePathAbsoluteFilesystem);
-    });
+    if (transformImports !== 'all') {
+        (0, utils_js_1.assert)(result.metafile);
+        Object.keys(result.metafile.inputs).forEach((filePathRelative) => {
+            filePathRelative = (0, utils_js_1.toPosixPath)(filePathRelative);
+            (0, utils_js_1.assertPosixPath)(userRootDir);
+            const filePathAbsoluteFilesystem = path_1.default.posix.join(userRootDir, filePathRelative);
+            getVikeConfig_js_1.vikeConfigDependencies.add(filePathAbsoluteFilesystem);
+        });
+    }
     const code = result.outputFiles[0].text;
     (0, utils_js_1.assert)(typeof code === 'string');
     return { code, pointerImports };

package/dist/cjs/utils/assertPathIsFilesystemAbsolute.js

@@ -11,11 +11,11 @@ const filesystemPathHandling_js_1 = require("./filesystemPathHandling.js");
 function assertPathIsFilesystemAbsolute(p) {
     (0, filesystemPathHandling_js_1.assertPosixPath)(p);
     (0, assert_js_1.assert)(!p.startsWith('/@fs/'));
-    if (process.platform !== 'win32') {
-        (0, assert_js_1.assert)(p.startsWith('/'));
+    if (process.platform === 'win32') {
+        (0, assert_js_1.assert)(path_1.default.win32.isAbsolute(p));
     }
     else {
-        (0, assert_js_1.assert)(path_1.default.win32.isAbsolute(p));
+        (0, assert_js_1.assert)(p.startsWith('/'));
     }
 }
 exports.assertPathIsFilesystemAbsolute = assertPathIsFilesystemAbsolute;

package/dist/cjs/utils/projectInfo.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = exports.projectInfo = void 0;
-const PROJECT_VERSION = '0.4.167-commit-4996ef0';
+const PROJECT_VERSION = '0.4.167-commit-cfadd0a';
 exports.PROJECT_VERSION = PROJECT_VERSION;
 const projectInfo = {
     projectName: 'Vike',

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

@@ -3,6 +3,7 @@ type HistoryState = {
     timestamp?: number;
     scrollPosition?: null | ScrollPosition;
     triggeredBy?: 'user' | 'vike' | 'browser';
+    _isVikeEnhanced: true;
 };
 type ScrollPosition = {
     x: number;

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

@@ -1,6 +1,5 @@
 export { initHistoryState, getHistoryState, pushHistory, saveScrollPosition, monkeyPatchHistoryPushState };
-import { assert, assertUsage, getGlobalObject, hasProp, isObject } from './utils.js';
-const globalObject = getGlobalObject('history.ts', {});
+import { assert, assertUsage, hasProp, isObject } from './utils.js';
 // Fill missing state information:
 //  - `history.state` can uninitialized (i.e. `null`):
 //    - The very first render
@@ -8,9 +7,10 @@ const globalObject = getGlobalObject('history.ts', {});
 //    - The user clicks on an anchor link `<a href="#section">Section</a>` (Vike's `onLinkClick()` handler skips hash links).
 //  - State information may be incomplete if `history.state` is set by an old Vike version. (E.g. `state.timestamp` was introduced for `pageContext.isBackwardNavigation` in `0.4.19`.)
 function initHistoryState() {
+    // No way found to add TypeScript types to `window.history.state`: https://github.com/microsoft/TypeScript/issues/36178
     let state = window.history.state;
     if (!state) {
-        state = {};
+        state = { _isVikeEnhanced: true };
     }
     let hasModifications = false;
     if (!('timestamp' in state)) {
@@ -49,7 +49,7 @@ function saveScrollPosition() {
 function pushHistory(url, overwriteLastHistoryEntry) {
     if (!overwriteLastHistoryEntry) {
         const timestamp = getTimestamp();
-        pushHistoryState({ timestamp, scrollPosition: null, triggeredBy: 'vike' }, url);
+        pushHistoryState({ timestamp, scrollPosition: null, triggeredBy: 'vike', _isVikeEnhanced: true }, url);
     }
     else {
         replaceHistoryState(getHistoryState(), url);
@@ -69,25 +69,29 @@ function assertState(state) {
     }
 }
 function replaceHistoryState(state, url) {
-    window.history.replaceState(state, '', url ?? /* Passing `undefined` chokes older Edge versions */ null);
+    const url_ = url ?? null; // Passing `undefined` chokes older Edge versions.
+    window.history.replaceState(state, '', url_);
 }
 function pushHistoryState(state, url) {
-    pushStateOriginal(state, '', url);
+    // Vike should call window.history.pushState() (and not the orignal `pushStateOriginal()`) so that other tools (e.g. user tracking) can listen to Vike's pushState() calls, see https://github.com/vikejs/vike/issues/1582.
+    window.history.pushState(state, '', url);
 }
 function monkeyPatchHistoryPushState() {
-    globalObject.pushStateOriginal = globalObject.pushStateOriginal ?? window.history.pushState;
-    window.history.pushState = (stateFromUser = {}, ...rest) => {
-        assertUsage(null === stateFromUser || undefined === stateFromUser || isObject(stateFromUser), 'history.pushState(state) argument state must be an object');
-        const state = {
-            scrollPosition: getScrollPosition(),
-            timestamp: getTimestamp(),
-            ...stateFromUser,
-            // Don't allow user to overwrite triggeredBy as it would break Vike's handling of the 'popstate' event
-            triggeredBy: 'user'
-        };
-        return pushStateOriginal(state, ...rest);
+    const pushStateOriginal = window.history.pushState.bind(window.history);
+    window.history.pushState = (stateOriginal = {}, ...rest) => {
+        assertUsage(stateOriginal === undefined || stateOriginal === null || isObject(stateOriginal), 'history.pushState(state) argument state must be an object');
+        const stateEnhanced = isVikeEnhanced(stateOriginal)
+            ? stateOriginal
+            : {
+                _isVikeEnhanced: true,
+                scrollPosition: getScrollPosition(),
+                timestamp: getTimestamp(),
+                triggeredBy: 'user',
+                ...stateOriginal
+            };
+        return pushStateOriginal(stateEnhanced, ...rest);
     };
 }
-function pushStateOriginal(...args) {
-    globalObject.pushStateOriginal.apply(history, args);
+function isVikeEnhanced(state) {
+    return isObject(state) && '_isVikeEnhanced' in state;
 }

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transformFileImports.d.ts

@@ -2,7 +2,7 @@ export { transformFileImports };
 export { parseImportData };
 export { isImportData };
 export type { ImportData };
-declare function transformFileImports(code: string, filePathToShowToUser2: string, pointerImports: Record<string, boolean> | 'all', skipWarnings?: true): string | null;
+declare function transformFileImports(code: string, filePathToShowToUser2: string, pointerImports: 'all' | Record<string, boolean>, skipWarnings?: true): string | null;
 /**
  * Data Structure holding info about import statement:
  *   `import { someExport as someImport } from './some-file'`

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

@@ -7,7 +7,7 @@ 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, assertPathIsFilesystemAbsolute } from '../../../../utils.js';
+import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, assertWarning, isObject, toPosixPath, assertUsage, isJavaScriptFile, createDebugger } from '../../../../utils.js';
 import { transformFileImports } from './transformFileImports.js';
 import { vikeConfigDependencies } from '../getVikeConfig.js';
 import 'source-map-support/register.js';
@@ -79,95 +79,98 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
         // Esbuild still sometimes removes unused imports because of TypeScript: https://github.com/evanw/esbuild/issues/3034
         treeShaking: false,
         minify: false,
-        metafile: true,
-        bundle: true
+        metafile: transformImports !== 'all',
+        bundle: transformImports !== 'all'
     };
-    let pointerImports = {};
-    options.plugins = [
-        // Determine whether an import should be:
-        //  - A pointer import
-        //  - Externalized
-        {
-            name: 'vike-esbuild-plugin',
-            setup(build) {
-                // https://github.com/evanw/esbuild/issues/3095#issuecomment-1546916366
-                const useEsbuildResolver = 'useEsbuildResolver';
-                // https://github.com/brillout/esbuild-playground
-                build.onResolve({ filter: /.*/ }, async (args) => {
-                    if (args.kind !== 'import-statement')
-                        return;
-                    if (args.pluginData?.[useEsbuildResolver])
-                        return;
-                    const { path, ...opts } = args;
-                    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.
-                        pointerImports[args.path] = false
-                        return { external: true }
-                        */
-                        // Let esbuild throw the error. (It throws a nice & pretty error.)
-                        return resolved;
-                    }
-                    assert(resolved.path);
-                    resolved.path = toPosixPath(resolved.path);
-                    // 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 = resolved.path.endsWith('+config.js');
-                    const isPointerImport = transformImports === 'all' ||
+    let pointerImports;
+    if (transformImports === 'all') {
+        pointerImports = 'all';
+        options.packages = 'external';
+    }
+    else {
+        const pointerImports_ = (pointerImports = {});
+        options.plugins = [
+            // Determine whether an import should be:
+            //  - A pointer import
+            //  - Externalized
+            {
+                name: 'vike-esbuild-plugin',
+                setup(build) {
+                    // https://github.com/evanw/esbuild/issues/3095#issuecomment-1546916366
+                    const useEsbuildResolver = 'useEsbuildResolver';
+                    // https://github.com/brillout/esbuild-playground
+                    build.onResolve({ filter: /.*/ }, async (args) => {
+                        if (args.kind !== 'import-statement')
+                            return;
+                        if (args.pluginData?.[useEsbuildResolver])
+                            return;
+                        const { path, ...opts } = args;
+                        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.
+                            pointerImports_[args.path] = false
+                            return { external: true }
+                            */
+                            // Let esbuild throw the error. (It throws a nice & pretty error.)
+                            return resolved;
+                        }
+                        assert(resolved.path);
+                        resolved.path = toPosixPath(resolved.path);
+                        // 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 = resolved.path.endsWith('+config.js');
+                        const isPointerImport = 
                         // .jsx, .vue, .svg, ... => obviously not config code
                         !isJavaScriptFile(resolved.path) ||
-                        // 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.
-                        //    - 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;
-                    pointerImports[resolved.path] = isPointerImport;
-                    assertPosixPath(resolved.path);
-                    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.)
-                        resolved.path.includes('/node_modules/');
-                    if (debug.isActivated)
-                        debug('onResolved()', { args, resolved, isPointerImport, isExternal });
-                    // We need esbuild to resolve path aliases so that we can use:
-                    //   isNpmPackageImport(str, { cannotBePathAlias: true })
-                    //   assertIsNpmPackageImport()
-                    assertPathIsFilesystemAbsolute(resolved.path);
-                    if (isExternal) {
-                        return { external: true, path: resolved.path };
-                    }
-                    else {
-                        return resolved;
-                    }
-                });
-            }
-        },
-        // Track dependencies
-        {
-            name: 'vike:dependency-tracker',
-            setup(b) {
-                b.onLoad({ filter: /./ }, (args) => {
-                    // We collect the dependency `args.path` in case the bulid fails (upon build error => error is thrown => no metafile)
-                    let { path } = args;
-                    path = toPosixPath(path);
-                    vikeConfigDependencies.add(path);
-                    return undefined;
-                });
-                /* To exhaustively collect all dependencies upon build failure, we would also need to use onResolve().
-                 *  - Because onLoad() isn't call if the config dependency can't be resolved.
-                 *  - For example, the following breaks auto-reload (the config is stuck in its error state and the user needs to touch the importer for the config to reload):
-                 *    ```bash
-                 *    mv ./some-config-dependency.js /tmp/ && mv /tmp/some-config-dependency.js .
-                 *    ```
-                 *  - But implementing a fix is complex and isn't worth it.
-                b.onResolve(...)
-                */
+                            // 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.
+                            //    - 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;
+                        pointerImports_[resolved.path] = isPointerImport;
+                        assertPosixPath(resolved.path);
+                        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.)
+                            resolved.path.includes('/node_modules/');
+                        if (debug.isActivated)
+                            debug('onResolved()', { args, resolved, isPointerImport, isExternal });
+                        if (isExternal) {
+                            return { external: true, path: resolved.path };
+                        }
+                        else {
+                            return resolved;
+                        }
+                    });
+                }
+            },
+            // Track dependencies
+            {
+                name: 'vike:dependency-tracker',
+                setup(b) {
+                    b.onLoad({ filter: /./ }, (args) => {
+                        // We collect the dependency `args.path` in case the bulid fails (upon build error => error is thrown => no metafile)
+                        let { path } = args;
+                        path = toPosixPath(path);
+                        vikeConfigDependencies.add(path);
+                        return undefined;
+                    });
+                    /* To exhaustively collect all dependencies upon build failure, we would also need to use onResolve().
+                     *  - Because onLoad() isn't call if the config dependency can't be resolved.
+                     *  - For example, the following breaks auto-reload (the config is stuck in its error state and the user needs to touch the importer for the config to reload):
+                     *    ```bash
+                     *    mv ./some-config-dependency.js /tmp/ && mv /tmp/some-config-dependency.js .
+                     *    ```
+                     *  - But implementing a fix is complex and isn't worth it.
+                    b.onResolve(...)
+                    */
+                }
             }
-        }
-    ];
+        ];
+    }
     let result;
     try {
         result = await build(options);
@@ -177,13 +180,15 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
         throw err;
     }
     // Track dependencies
-    assert(result.metafile);
-    Object.keys(result.metafile.inputs).forEach((filePathRelative) => {
-        filePathRelative = toPosixPath(filePathRelative);
-        assertPosixPath(userRootDir);
-        const filePathAbsoluteFilesystem = path.posix.join(userRootDir, filePathRelative);
-        vikeConfigDependencies.add(filePathAbsoluteFilesystem);
-    });
+    if (transformImports !== 'all') {
+        assert(result.metafile);
+        Object.keys(result.metafile.inputs).forEach((filePathRelative) => {
+            filePathRelative = toPosixPath(filePathRelative);
+            assertPosixPath(userRootDir);
+            const filePathAbsoluteFilesystem = path.posix.join(userRootDir, filePathRelative);
+            vikeConfigDependencies.add(filePathAbsoluteFilesystem);
+        });
+    }
     const code = result.outputFiles[0].text;
     assert(typeof code === 'string');
     return { code, pointerImports };

package/dist/esm/utils/assertPathIsFilesystemAbsolute.js

@@ -6,10 +6,10 @@ import { assertPosixPath } from './filesystemPathHandling.js';
 function assertPathIsFilesystemAbsolute(p) {
     assertPosixPath(p);
     assert(!p.startsWith('/@fs/'));
-    if (process.platform !== 'win32') {
-        assert(p.startsWith('/'));
+    if (process.platform === 'win32') {
+        assert(path.win32.isAbsolute(p));
     }
     else {
-        assert(path.win32.isAbsolute(p));
+        assert(p.startsWith('/'));
     }
 }

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

@@ -1,7 +1,7 @@
 export { projectInfo };
 export { PROJECT_VERSION };
-declare const PROJECT_VERSION: "0.4.167-commit-4996ef0";
+declare const PROJECT_VERSION: "0.4.167-commit-cfadd0a";
 declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.167-commit-4996ef0";
+    projectVersion: "0.4.167-commit-cfadd0a";
 };

package/dist/esm/utils/projectInfo.js

@@ -1,6 +1,6 @@
 export { projectInfo };
 export { PROJECT_VERSION };
-const PROJECT_VERSION = '0.4.167-commit-4996ef0';
+const PROJECT_VERSION = '0.4.167-commit-cfadd0a';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.167-commit-4996ef0",
+  "version": "0.4.167-commit-cfadd0a",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",