vike 0.4.161 → 0.4.162

package/dist/cjs/node/plugin/plugins/importUserCode/index.js

@@ -38,7 +38,7 @@ function importUserCode() {
         },
         handleHotUpdate(ctx) {
             try {
-                return handleHotUpdate(ctx, config, configVike);
+                return handleHotUpdate(ctx, config);
             }
             catch (err) {
                 // Vite swallows errors thrown by handleHotUpdate()
@@ -62,12 +62,12 @@ function importUserCode() {
         },
         configureServer(server) {
             (0, utils_js_1.isDev1_onConfigureServer)();
-            handleFileAddRemove(server, config, configVike);
+            handleFileAddRemove(server, config);
         }
     };
 }
 exports.importUserCode = importUserCode;
-function handleFileAddRemove(server, config, configVike) {
+function handleFileAddRemove(server, config) {
     server.watcher.prependListener('add', (f) => listener(f, false));
     server.watcher.prependListener('unlink', (f) => listener(f, true));
     return;
@@ -79,11 +79,11 @@ function handleFileAddRemove(server, config, configVike) {
             virtualModules.forEach((mod) => {
                 server.moduleGraph.invalidateModule(mod);
             });
-            reloadConfig(file, config, configVike, isRemove ? 'removed' : 'created');
+            reloadConfig(file, config, isRemove ? 'removed' : 'created');
         }
     }
 }
-function handleHotUpdate(ctx, config, configVike) {
+function handleHotUpdate(ctx, config) {
     const { file, server } = ctx;
     (0, utils_js_1.assertPosixPath)(file);
     getVikeConfig_js_1.vikeConfigDependencies.forEach((f) => (0, utils_js_1.assertPosixPath)(f));
@@ -114,7 +114,7 @@ function handleHotUpdate(ctx, config, configVike) {
         /* Tailwind breaks this assertion, see https://github.com/vikejs/vike/discussions/1330#discussioncomment-7787238
         assert(!isViteModule)
         */
-        reloadConfig(file, config, configVike, 'modified');
+        reloadConfig(file, config, 'modified');
         const virtualModules = getVirtualModules(server);
         return virtualModules;
     }
@@ -122,13 +122,13 @@ function handleHotUpdate(ctx, config, configVike) {
 function isVikeConfigModule(filePathAbsoluteFilesystem) {
     return getVikeConfig_js_1.vikeConfigDependencies.has(filePathAbsoluteFilesystem);
 }
-function reloadConfig(filePath, config, configVike, op) {
+function reloadConfig(filePath, config, op) {
     {
         const filePathToShowToUser = picocolors_1.default.dim((0, utils_js_1.getFilePathRelativeToUserRootDir)(filePath, config.root, true));
         const msg = `${op} ${filePathToShowToUser}`;
         (0, loggerNotProd_js_1.logConfigInfo)(msg, 'info');
     }
-    (0, getVikeConfig_js_1.reloadVikeConfig)(config.root, (0, utils_js_1.getOutDirs)(config).outDirRoot, configVike.extensions);
+    (0, getVikeConfig_js_1.reloadVikeConfig)(config.root, (0, utils_js_1.getOutDirs)(config).outDirRoot);
 }
 function getVirtualModules(server) {
     const virtualModules = Array.from(server.moduleGraph.urlToModuleMap.keys())

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

@@ -66,15 +66,7 @@ function getConfigValueSerialized(value, configName, definedAt) {
         */
         const configValueFilePathToShowToUser = (0, helpers_js_1.getConfigValueFilePathToShowToUser)({ definedAt });
         (0, utils_js_1.assert)(configValueFilePathToShowToUser);
-        (0, utils_js_1.assertUsage)(false, [
-            `The code of ${picocolors_1.default.cyan(configName)} cannot live inside ${configValueFilePathToShowToUser},`,
-            'see https://vike.dev/header-file#runtime-code'
-            /* I guess showing this is more confusing than adding value.
-            `(technically speaking: the value of ${pc.cyan(
-              configName
-            )} isn't serializable (${serializationErrMsg}) and it's therefore runtime code that needs to be imported).`
-            //*/
-        ].join(' '));
+        (0, utils_js_1.assertUsage)(false, `${picocolors_1.default.cyan(configName)} defined by ${configValueFilePathToShowToUser} must be defined over a so-called "pointer import", see https://vike.dev/config#pointer-imports`);
     }
     configValueSerialized = JSON.stringify(configValueSerialized);
     return configValueSerialized;

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

@@ -89,6 +89,9 @@ const configDefinitionsBuiltIn = {
     },
     cacheControl: {
         env: { server: true }
+    },
+    name: {
+        env: { config: true }
     }
 };
 exports.configDefinitionsBuiltIn = configDefinitionsBuiltIn;

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

@@ -9,7 +9,7 @@ const utils_js_1 = require("../../../../utils.js");
  * The value `locationId` is always a user-land path, because Filesystem Routing/Inheritance only applies to the user-land (Vike never uses Filesystem Routing/Inheritance for `node_modules/**`).
  */
 function getLocationId(
-// We always determine `locationId` from a real user-land file: the `locationId` for Vike extensions is the `locationId` of the the user's `+config.h.js` that extends the Vike extension.
+// We always determine `locationId` from a real user-land file: the `locationId` for Vike extensions is the `locationId` of the the user's `+config.js` that extends the Vike extension.
 filePathRelativeToUserRootDir) {
     (0, utils_js_1.assertPosixPath)(filePathRelativeToUserRootDir);
     (0, utils_js_1.assert)(filePathRelativeToUserRootDir.startsWith('/'));

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

@@ -17,7 +17,7 @@ const resolveImportPath_js_1 = require("./resolveImportPath.js");
 async function loadImportedFile(import_, userRootDir, importedFilesLoaded) {
     const f = import_.filePathAbsoluteFilesystem;
     if (!importedFilesLoaded[f]) {
-        importedFilesLoaded[f] = (0, transpileAndExecuteFile_js_1.transpileAndExecuteFile)(import_, false, userRootDir).then((r) => r.fileExports);
+        importedFilesLoaded[f] = (0, transpileAndExecuteFile_js_1.transpileAndExecuteFile)(import_, userRootDir, false).then((r) => r.fileExports);
     }
     const fileExports = await importedFilesLoaded[f];
     const fileExport = fileExports[import_.fileExportName];
@@ -26,7 +26,7 @@ async function loadImportedFile(import_, userRootDir, importedFilesLoaded) {
 exports.loadImportedFile = loadImportedFile;
 // Load +{configName}.js
 async function loadValueFile(interfaceValueFile, configName, userRootDir) {
-    const { fileExports } = await (0, transpileAndExecuteFile_js_1.transpileAndExecuteFile)(interfaceValueFile.filePath, false, userRootDir);
+    const { fileExports } = await (0, transpileAndExecuteFile_js_1.transpileAndExecuteFile)(interfaceValueFile.filePath, userRootDir, false);
     const { filePathToShowToUser } = interfaceValueFile.filePath;
     (0, assertPlusFileExport_js_1.assertPlusFileExport)(fileExports, filePathToShowToUser, configName);
     Object.entries(fileExports).forEach(([exportName, configValue]) => {
@@ -36,10 +36,10 @@ async function loadValueFile(interfaceValueFile, configName, userRootDir) {
 }
 exports.loadValueFile = loadValueFile;
 // Load +config.js, including all its extends fake imports
-async function loadConfigFile(configFilePath, userRootDir, visited, isConfigOfExtension) {
+async function loadConfigFile(configFilePath, userRootDir, visited, isExtensionConfig) {
     const { filePathAbsoluteFilesystem } = configFilePath;
     assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem);
-    const { fileExports } = await (0, transpileAndExecuteFile_js_1.transpileAndExecuteFile)(configFilePath, !isConfigOfExtension, userRootDir, isConfigOfExtension);
+    const { fileExports } = await (0, transpileAndExecuteFile_js_1.transpileAndExecuteFile)(configFilePath, userRootDir, isExtensionConfig ? 'is-extension-config' : true);
     const { extendsConfigs, extendsFilePaths } = await loadExtendsConfigs(fileExports, configFilePath, userRootDir, [
         ...visited,
         filePathAbsoluteFilesystem

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

@@ -120,7 +120,7 @@ function assertFileEnv(filePathForEnvCheck, configEnv, configName) {
         (0, utils_js_1.assertUsage)(false, [
             `${filePathForEnvCheck} 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))}`),
-            'Defining config values in the same file is allowed only if they live in the same environment, see https://vike.dev/header-file'
+            '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

@@ -5,52 +5,55 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isImportData = exports.parseImportData = exports.transformFileImports = void 0;
 // Playground: https://github.com/brillout/acorn-playground
-// Import attributes support: https://github.com/acornjs/acorn/issues/983
-//  - Isn't stage 4 yet: https://github.com/tc39/proposal-import-attributes
+// Notes about `with { type: 'pointer' }`
+// - It works well with TypeScript: it doesn't complain upon `with { type: 'unknown-to-typescript' }` and go-to-definition & types are preserved: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-3.html#import-attributes
+// - Acorn support for import attributes: https://github.com/acornjs/acorn/issues/983
+//   - Acorn plugin: https://github.com/acornjs/acorn/issues/983
+//   - Isn't stage 4 yet: https://github.com/tc39/proposal-import-attributes
+// - Using a import path suffix such as `import { Layout } from './Layout?real` breaks TypeScript, and TypeScript isn't working on supporting query params: https://github.com/microsoft/TypeScript/issues/10988#issuecomment-867135453
+// - Node.js >=21 supports import attribtues: https://nodejs.org/api/esm.html#import-attributes
+// - Esbuid supports
+//   - Blocker: https://github.com/evanw/esbuild/issues/3646
+//     - Ugly hack to make it work: https://github.com/brillout/esbuild-playground/tree/experiment/import-attribute
+//   - Discussion with esbuild maintainer: https://github.com/evanw/esbuild/issues/3384
+// - Using a magic comment `// @vike-real-import` is probably a bad idea:
+//   - Esbuild removes comments: https://github.com/evanw/esbuild/issues/1439#issuecomment-877656182
+//   - Using source maps to track these magic comments is brittle (source maps can easily break)
 const acorn_1 = require("acorn");
 const utils_js_1 = require("../../../../utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-function transformFileImports(code, filePathToShowToUser2, 
+// TODO: rename transformFileImports() => transformPointerImports()
+function transformFileImports(code, filePathToShowToUser2, pointerImports, 
 // For ./transformFileImports.spec.ts
 skipWarnings) {
     const spliceOperations = [];
-    const fileImportsTransformed = [];
     // Performance trick
     if (!code.includes('import'))
-        return { noTransformation: true };
+        return null;
     const imports = getImports(code);
     if (imports.length === 0)
-        return { noTransformation: true };
+        return null;
     imports.forEach((node) => {
         if (node.type !== 'ImportDeclaration')
             return;
         const importPath = node.source.value;
         (0, utils_js_1.assert)(typeof importPath === 'string');
-        // - This doesn't work. To make it work we would need to run esbuild twice: esbuild for TypeScript to JavaScript => transformFileImports() => esbuild for bundling.
-        //   - Or we use an esbuild plugin to apply transformFileImports(). Maybe we can completely skip the need for acorn?
-        // - ?real breaks TypeScript, and TypeScript isn't working on supporting query params: https://github.com/microsoft/TypeScript/issues/10988#issuecomment-867135453
-        // - Import attributes would be the best.
-        //   - But it only works with Node.js >=21: https://nodejs.org/api/esm.html#import-attributes
-        //     - But it's probably ok to tell users "to use real imports you need Node.js 21 or above".
-        //   - It works well with TypeScript: it doesn't complain upon `with { type: 'unknown-to-typescript' }` and go-to-definition & types are preserved: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-3.html#import-attributes
-        //   - Esbuid seems to support it: https://esbuild.github.io/plugins/#on-load-arguments:~:text=This%20contains%20a%20map%20of%20the%20import%20attributes%20that
-        //   - acorn supports it over an acorn plugin: https://github.com/acornjs/acorn/issues/983
-        //     - Maybe we can use an esbuild plugin instead of acorn to apply transformFileImports()?
-        // - Using a magic comment `// @vike-real-import` is tricky:
-        //   - Esbuild removes comments: https://github.com/evanw/esbuild/issues/1439#issuecomment-877656182
-        //   - Using source maps to track these magic comments is brittle (source maps can easily break)
-        if (importPath.endsWith('?real')) {
-            const { start, end } = node.source;
-            spliceOperations.push({
-                start,
-                end,
-                replacement: importPath.slice(0, -1 * '?real'.length)
-            });
-            return;
+        if (pointerImports !== 'all') {
+            (0, utils_js_1.assert)(importPath in pointerImports);
+            const isPointerImport = pointerImports[importPath];
+            (0, utils_js_1.assert)(isPointerImport === true || isPointerImport === false);
+            if (!isPointerImport)
+                return;
         }
         const { start, end } = node;
         const importStatementCode = code.slice(start, end);
-        // No variable imported
+        /* Pointer import without importing any value => doesn't make sense and doesn't have any effect.
+        ```js
+        // Useless
+        import './some.css'
+        // Useless
+        import './Layout.jsx'
+        ``` */
         if (node.specifiers.length === 0) {
             const isWarning = !utils_js_1.styleFileRE.test(importPath);
             let quote = indent(importStatementCode);
@@ -61,8 +64,9 @@ skipWarnings) {
                 quote = picocolors_1.default.bold(picocolors_1.default.red(quote));
             }
             const errMsg = [
-                `As explained in https://vike.dev/header-file the following import in ${filePathToShowToUser2} has no effect:`,
-                quote
+                `The following import in ${filePathToShowToUser2} has no effect:`,
+                quote,
+                'See https://vike.dev/config#pointer-imports'
             ].join('\n');
             if (!skipWarnings) {
                 if (!isWarning) {
@@ -91,11 +95,6 @@ skipWarnings) {
             })();
             const importString = serializeImportData({ importPath, exportName, importStringWasGenerated: true });
             replacement += `const ${importLocalName} = '${importString}';`;
-            fileImportsTransformed.push({
-                importStatementCode,
-                importString,
-                importLocalName
-            });
         });
         spliceOperations.push({
             start,
@@ -104,7 +103,7 @@ skipWarnings) {
         });
     });
     const codeMod = spliceMany(code, spliceOperations);
-    return { code: codeMod, fileImportsTransformed, noTransformation: false };
+    return codeMod;
 }
 exports.transformFileImports = transformFileImports;
 function getImports(code) {

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

@@ -13,62 +13,55 @@ const utils_js_1 = require("../../../../utils.js");
 const transformFileImports_js_1 = require("./transformFileImports.js");
 const getVikeConfig_js_1 = require("../getVikeConfig.js");
 require("source-map-support/register.js");
-const getConfigFileExport_js_1 = require("../getConfigFileExport.js");
 (0, utils_js_1.assertIsNotProductionRuntime)();
-async function transpileAndExecuteFile(filePath, transformImports, userRootDir, doNotTranspile = false) {
-    if (doNotTranspile) {
-        (0, utils_js_1.assert)(!transformImports);
-        const fileExports = await executeFile(filePath.filePathAbsoluteFilesystem, filePath);
-        if (isHeaderFile(filePath.filePathAbsoluteFilesystem)) {
-            const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
-            (0, utils_js_1.assertWarning)(false, `${filePathToShowToUser2} is a JavaScript header file (.h.js), but JavaScript header files don't apply to the config files of extensions`, { onlyOnce: true });
-        }
+const debug = (0, utils_js_1.createDebugger)('vike:pointer-imports');
+async function transpileAndExecuteFile(filePath, userRootDir, isConfigFile) {
+    const { filePathAbsoluteFilesystem } = filePath;
+    const fileExtension = getFileExtension(filePathAbsoluteFilesystem);
+    const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
+    (0, utils_js_1.assertUsage)((0, utils_js_1.isJavaScriptFile)(filePathAbsoluteFilesystem), `${filePathToShowToUser2} 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 ${filePathToShowToUser2} to ${removeHeaderFileExtension(filePathToShowToUser2)} 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 });
+    }
+    if (isConfigFile === 'is-extension-config' && !isHeader && fileExtension.endsWith('js')) {
+        // This doesn't track dependencies => we should never use this for user land configs
+        const fileExports = await executeFile(filePathAbsoluteFilesystem, filePath);
         return { fileExports };
     }
     else {
-        const { code, fileImportsTransformed } = await transpileFile(filePath, transformImports, userRootDir);
-        const fileExports = await executeTranspiledFile(filePath, code, fileImportsTransformed);
+        const transformImports = isConfigFile && (isHeader ? 'all' : true);
+        const code = await transpileFile(filePath, transformImports, userRootDir);
+        const fileExports = await executeTranspiledFile(filePath, code);
         return { fileExports };
     }
 }
 exports.transpileAndExecuteFile = transpileAndExecuteFile;
 async function transpileFile(filePath, transformImports, userRootDir) {
-    const { filePathAbsoluteFilesystem } = filePath;
     const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
+    const { filePathAbsoluteFilesystem } = filePath;
     (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
     getVikeConfig_js_1.vikeConfigDependencies.add(filePathAbsoluteFilesystem);
-    let code = await transpileWithEsbuild(filePath, userRootDir, transformImports);
-    let fileImportsTransformed = null;
+    if (debug.isEnabled)
+        debug('transpile', filePathToShowToUser2);
+    let { code, pointerImports } = await transpileWithEsbuild(filePath, userRootDir, transformImports);
+    if (debug.isEnabled)
+        debug(`code, post esbuild (${filePathToShowToUser2})`, code);
+    let isImportTransformed = false;
     if (transformImports) {
-        const res = transformFileImports_(code, filePath);
-        if (res) {
-            code = res.code;
-            fileImportsTransformed = res.fileImportsTransformed;
+        const codeMod = (0, transformFileImports_js_1.transformFileImports)(code, filePathToShowToUser2, pointerImports);
+        if (codeMod) {
+            code = codeMod;
+            isImportTransformed = true;
+            if (debug.isEnabled)
+                debug(`code, post transformImports() (${filePathToShowToUser2})`, code);
         }
     }
-    else {
-        if (isHeaderFile(filePathAbsoluteFilesystem)) {
-            (0, utils_js_1.assertWarning)(false, `${filePathToShowToUser2} is a JavaScript header file (.h.js), but JavaScript header files only apply to +config.h.js, see https://vike.dev/header-file`, { onlyOnce: true });
-        }
+    if (!isImportTransformed) {
+        if (debug.isEnabled)
+            debug(`code, no transformImports() (${filePathToShowToUser2})`);
     }
-    return { code, fileImportsTransformed };
-}
-function transformFileImports_(codeOriginal, filePath) {
-    const { filePathAbsoluteFilesystem } = filePath;
-    const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
-    // Replace import statements with import strings
-    const res = (0, transformFileImports_js_1.transformFileImports)(codeOriginal, filePathToShowToUser2);
-    if (res.noTransformation) {
-        return null;
-    }
-    const { code, fileImportsTransformed } = res;
-    if (!isHeaderFile(filePathAbsoluteFilesystem)) {
-        const filePathCorrect = appendHeaderFileExtension(filePathToShowToUser2);
-        (0, utils_js_1.assertWarning)(false, `Rename ${filePathToShowToUser2} to ${filePathCorrect}, see https://vike.dev/header-file`, {
-            onlyOnce: true
-        });
-    }
-    return { code, fileImportsTransformed };
+    return code;
 }
 async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
     const entryFilePath = filePath.filePathAbsoluteFilesystem;
@@ -91,14 +84,63 @@ 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: !transformImports,
-        // We cannot bundle imports that are meant to be transformed
-        bundle: !transformImports
+        metafile: transformImports !== 'all',
+        bundle: transformImports !== 'all'
     };
-    // Track dependencies
-    if (!transformImports) {
+    let pointerImports;
+    if (transformImports === 'all') {
+        pointerImports = 'all';
         options.packages = 'external';
+    }
+    else {
+        const pointerImports_ = (pointerImports = {});
         options.plugins = [
+            // Determine what import should be externalized (and then transformed to a pointer/fake import)
+            {
+                name: 'vike:externalize-heuristic',
+                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 isImportAbsolute = !args.path.startsWith('.');
+                        const { path, ...opts } = args;
+                        opts.pluginData = { [useEsbuildResolver]: true };
+                        const resolved = await build.resolve(path, opts);
+                        // 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_[args.path] = isPointerImport;
+                        const isExternal = isPointerImport ||
+                            // npm package imports that aren't pointer imports (e.g. Vite plugin import)
+                            isImportAbsolute;
+                        if (debug.isEnabled)
+                            debug('onResolved()', { args, resolved, isPointerImport, isExternal });
+                        if (isExternal) {
+                            return { external: true, path: args.path };
+                        }
+                        else {
+                            return resolved;
+                        }
+                    });
+                }
+            },
+            // Track dependencies
             {
                 name: 'vike:dependency-tracker',
                 setup(b) {
@@ -131,7 +173,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
         throw err;
     }
     // Track dependencies
-    if (!transformImports) {
+    if (transformImports !== 'all') {
         (0, utils_js_1.assert)(result.metafile);
         Object.keys(result.metafile.inputs).forEach((filePathRelative) => {
             filePathRelative = (0, utils_js_1.toPosixPath)(filePathRelative);
@@ -142,10 +184,10 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
     }
     const code = result.outputFiles[0].text;
     (0, utils_js_1.assert)(typeof code === 'string');
-    return code;
+    return { code, pointerImports };
 }
-async function executeTranspiledFile(filePath, code, fileImportsTransformed) {
-    const { filePathAbsoluteFilesystem, filePathRelativeToUserRootDir } = filePath;
+async function executeTranspiledFile(filePath, code) {
+    const { filePathAbsoluteFilesystem } = filePath;
     // Alternative to using a temporary file: https://github.com/vitejs/vite/pull/13269
     //  - But seems to break source maps, so I don't think it's worth it
     const filePathTmp = getFilePathTmp(filePathAbsoluteFilesystem);
@@ -158,11 +200,6 @@ async function executeTranspiledFile(filePath, code, fileImportsTransformed) {
     finally {
         clean();
     }
-    if (fileImportsTransformed) {
-        (0, utils_js_1.assert)(filePathRelativeToUserRootDir !== undefined);
-        const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
-        assertImportsAreReExported(fileImportsTransformed, fileExports, filePathToShowToUser2);
-    }
     return fileExports;
 }
 async function executeFile(filePathToExecuteAbsoluteFilesystem, filePathSourceFile) {
@@ -228,59 +265,27 @@ function isTmpFile(filePath) {
     return fileName.startsWith(tmpPrefix);
 }
 exports.isTmpFile = isTmpFile;
-function assertImportsAreReExported(fileImportsTransformed, fileExports, filePathToShowToUser2) {
-    const fileExport = (0, getConfigFileExport_js_1.getConfigFileExport)(fileExports, filePathToShowToUser2);
-    const exportedStrings = getExportedStrings(fileExport);
-    Object.values(exportedStrings).forEach((exportVal) => {
-        if (typeof exportVal !== 'string')
-            return;
-        if (!(0, transformFileImports_js_1.isImportData)(exportVal))
-            return;
-        const importString = exportVal;
-        fileImportsTransformed.forEach((fileImport) => {
-            if (fileImport.importString === importString) {
-                fileImport.isReExported = true;
-            }
-        });
-    });
-    const fileImportsTransformedUnused = fileImportsTransformed.filter((fi) => !fi.isReExported);
-    if (fileImportsTransformedUnused.length === 0)
-        return;
-    const importStatements = (0, utils_js_1.unique)(fileImportsTransformedUnused.map((fi) => fi.importStatementCode));
-    const importNamesUnused = fileImportsTransformedUnused.map((fi) => picocolors_1.default.cyan(fi.importLocalName)).join(', ');
-    const singular = fileImportsTransformedUnused.length === 1;
-    (0, utils_js_1.assertWarning)(fileImportsTransformedUnused.length === 0, [
-        `${filePathToShowToUser2} imports the following:`,
-        ...importStatements.map((s) => picocolors_1.default.cyan(`  ${s}`)),
-        `But the import${singular ? '' : 's'} ${importNamesUnused} ${singular ? "isn't" : "aren't"} re-exported at ${picocolors_1.default.cyan('export default { ... }')} and therefore ${singular ? 'has' : 'have'} no effect, see explanation at https://vike.dev/header-file`
-    ].join('\n'), { onlyOnce: true });
-}
-function getExportedStrings(obj) {
-    const exportedStrings = [];
-    Object.values(obj).forEach((val) => {
-        if (typeof val === 'string') {
-            exportedStrings.push(val);
-        }
-        else if (Array.isArray(val)) {
-            val.forEach((v) => {
-                if (typeof v === 'string') {
-                    exportedStrings.push(v);
-                }
-            });
-        }
-    });
-    return exportedStrings;
-}
 function isHeaderFile(filePath) {
     (0, utils_js_1.assertPosixPath)(filePath);
-    const basenameParts = path_1.default.posix.basename(filePath).split('.');
-    return basenameParts.includes('h');
+    const fileExtensions = getFileExtensions(filePath);
+    return fileExtensions.includes('h');
 }
-function appendHeaderFileExtension(filePath) {
-    const basenameParts = path_1.default.posix.basename(filePath).split('.');
-    basenameParts.splice(-1, 0, 'h');
-    const basenameCorrect = basenameParts.join('.');
-    return path_1.default.posix.join(path_1.default.posix.dirname(filePath), basenameCorrect);
+function getFileExtensions(filePath) {
+    const fileExtensions = path_1.default.posix.basename(filePath).split('.').slice(1);
+    return fileExtensions;
+}
+function getFileExtension(filePath) {
+    const fileExtensions = path_1.default.posix.basename(filePath).split('.').slice(1);
+    return fileExtensions.pop();
+}
+function removeHeaderFileExtension(filePath) {
+    (0, utils_js_1.assertPosixPath)(filePath);
+    const fileName = path_1.default.posix.basename(filePath);
+    const fileNameParts = fileName.split('.');
+    const fileNamePartsMod = fileNameParts.filter((p) => p !== 'h');
+    (0, utils_js_1.assert)(fileNamePartsMod.length < fileNameParts.length);
+    const fileNameMod = fileNamePartsMod.join('.');
+    return path_1.default.posix.join(path_1.default.posix.dirname(filePath), fileNameMod);
 }
 // Needed for the npm package 'source-map-support'. The Error.prepareStackTrace() hook of 'source-map-support' needs to be called before the file containing the source map is removed. The clean() call above removes the transpiled file from disk but it contains the inline source map.
 function triggerPrepareStackTrace(err) {