vike 0.4.161 → 0.4.162-commit-49fe40c

package/dist/esm/node/plugin/plugins/extractAssetsPlugin.js

@@ -11,10 +11,11 @@ import { extractAssetsAddQuery } from '../../shared/extractAssetsQuery.js';
 import { getConfigVike } from '../../shared/getConfigVike.js';
 import { isAsset } from '../shared/isAsset.js';
 import { getImportStatements } from '../shared/parseEsModule.js';
-import { removeSourceMap } from '../shared/removeSourceMap.js';
+import { sourceMapRemove } from '../shared/rollupSourceMap.js';
 import pc from '@brillout/picocolors';
 import { fixServerAssets_isEnabled } from './buildConfig/fixServerAssets.js';
-import { isV1Design } from './importUserCode/v1-design/getVikeConfig.js';
+import { getVikeConfig, isV1Design } from './importUserCode/v1-design/getVikeConfig.js';
+import { assertV1Design } from '../../shared/assertV1Design.js';
 const extractAssetsRE = /(\?|&)extractAssets(?:&|$)/;
 const rawRE = /(\?|&)raw(?:&|$)/;
 const urlRE = /(\?|&)url(?:&|$)/;
@@ -25,6 +26,7 @@ const debugEnabled = isDebugEnabled(debugNamespace);
 function extractAssetsPlugin() {
     let config;
     let configVike;
+    let vikeConfig;
     let isServerAssetsFixEnabled;
     return [
         // This plugin removes all JavaScript from server-side only code, so that only CSS imports remains. (And also satic files imports e.g. `import logoURL from './logo.svg.js'`).
@@ -37,14 +39,18 @@ function extractAssetsPlugin() {
                 if (!extractAssetsRE.test(id)) {
                     return;
                 }
-                assert(!isServerAssetsFixEnabled);
+                if (isServerAssetsFixEnabled) {
+                    // I'm guessing isServerAssetsFixEnabled can only be true when mixing both designs: https://github.com/vikejs/vike/issues/1480
+                    assertV1Design(true, vikeConfig.pageConfigs);
+                    assert(false);
+                }
                 assert(configVike.includeAssetsImportedByServer);
                 assert(!viteIsSSR_options(options));
                 const importStatements = await getImportStatements(src);
                 const moduleNames = getImportedModules(importStatements);
                 const code = moduleNames.map((moduleName) => `import '${moduleName}';`).join('\n');
                 debugTransformResult(id, code, importStatements);
-                return removeSourceMap(code);
+                return sourceMapRemove(code);
             }
         },
         // This plugin appends `?extractAssets` to module IDs
@@ -95,25 +101,6 @@ function extractAssetsPlugin() {
                 if (!isScriptFile(file)) {
                     return emptyModule(file, importer);
                 }
-                // If the dependency is a Vike extension and has `configVike.extension[number].pageConfigsSrcDir`, then include its CSS
-                if (configVike.extensions
-                    .filter(({ pageConfigsSrcDir }) => pageConfigsSrcDir !== null)
-                    .some(({ npmPackageName }) => {
-                    const check1 = source === npmPackageName ||
-                        source.startsWith(npmPackageName + '/') ||
-                        // Include relative imports within modules of `npmPackageName`. (This only works for dependencies: user may use import path aliases.)
-                        source.startsWith('.');
-                    // This doesn't work for linked dependencies
-                    const check2 = file.includes('node_modules/' + npmPackageName + '/') ||
-                        file.includes('node_modules\\' + npmPackageName + '\\');
-                    if (check1) {
-                        return true;
-                    }
-                    assert(!check2);
-                    return false;
-                })) {
-                    return appendExtractAssetsQuery(file, importer);
-                }
                 // If the import path resolves to a file in `node_modules/`, we ignore that file:
                 //  - Direct CSS dependencies are included though, such as `import 'bootstrap/theme/dark.css'`. (Because the above if-branch for CSS files will add the file.)
                 //  - Loading CSS from a library (living in `node_modules/`) in a non-direct way is non-standard; we can safely not support this case. (I'm not aware of any library that does this.)
@@ -135,6 +122,7 @@ function extractAssetsPlugin() {
             async configResolved(config_) {
                 configVike = await getConfigVike(config_);
                 config = config_;
+                vikeConfig = await getVikeConfig(config, false);
                 isServerAssetsFixEnabled = fixServerAssets_isEnabled() && (await isV1Design(config, false));
             },
             load(id) {

package/dist/esm/node/plugin/plugins/extractExportNamesPlugin.js

@@ -3,7 +3,7 @@ export { isUsingClientRouter };
 export { extractExportNamesRE };
 import { assert, getFileExtension, viteIsSSR_options, createDebugger, isDebugEnabled, getGlobalObject, assertUsage } from '../utils.js';
 import { getExportNames } from '../shared/parseEsModule.js';
-import { removeSourceMap } from '../shared/removeSourceMap.js';
+import { sourceMapRemove } from '../shared/rollupSourceMap.js';
 const extractExportNamesRE = /(\?|&)extractExportNames(?:&|$)/;
 const debugNamespace = 'vike:extractExportNames';
 const debug = createDebugger(debugNamespace);
@@ -38,7 +38,7 @@ async function getExtractExportNamesCode(src, isClientSide, isProduction, id) {
         globalObject.usesClientRouter = true;
     }
     const code = getCode(exportNames, wildcardReExports, isClientSide, isProduction, id);
-    return removeSourceMap(code);
+    return sourceMapRemove(code);
 }
 function getCode(exportNames, wildcardReExports, isClientSide, isProduction, id) {
     let code = '';

package/dist/esm/node/plugin/plugins/importBuild/getVikeManifest.d.ts

@@ -1,5 +1,4 @@
 export { getVikeManifest };
-import { ResolvedConfig } from 'vite';
 import { type PluginManifest } from '../../../shared/assertPluginManifest.js';
 import type { ConfigVikeResolved } from '../../../../shared/ConfigVike.js';
-declare function getVikeManifest(config: ResolvedConfig, configVike: ConfigVikeResolved): PluginManifest;
+declare function getVikeManifest(configVike: ConfigVikeResolved): PluginManifest;

package/dist/esm/node/plugin/plugins/importBuild/getVikeManifest.js

@@ -1,32 +1,15 @@
 export { getVikeManifest };
-import { projectInfo, toPosixPath, assertPosixPath, isNotNullish } from '../../utils.js';
+import { projectInfo } from '../../utils.js';
 import { assertPluginManifest } from '../../../shared/assertPluginManifest.js';
 import { isUsingClientRouter } from '../extractExportNamesPlugin.js';
-import path from 'path';
 import { getRuntimeManifest } from '../../../runtime/globalContext.js';
-function getVikeManifest(config, configVike) {
+function getVikeManifest(configVike) {
     const runtimeManifest = getRuntimeManifest(configVike);
     const manifest = {
         version: projectInfo.projectVersion,
         usesClientRouter: isUsingClientRouter(), // TODO/v1-release: remove
-        manifestKeyMap: getManifestKeyMap(configVike, config),
         ...runtimeManifest
     };
     assertPluginManifest(manifest);
     return manifest;
 }
-function getManifestKeyMap(configVike, config) {
-    const manifestKeyMap = {};
-    configVike.extensions
-        .map(({ pageConfigsDistFiles }) => pageConfigsDistFiles)
-        .flat()
-        .filter(isNotNullish)
-        .forEach(({ importPath, filePath }) => {
-        // Recreating https://github.com/vitejs/vite/blob/8158ece72b66307e7b607b98496891610ca70ea2/packages/vite/src/node/plugins/manifest.ts#L38
-        const filePathRelative = path.posix.relative(config.root, toPosixPath(filePath));
-        assertPosixPath(filePathRelative);
-        assertPosixPath(importPath);
-        manifestKeyMap[importPath] = filePathRelative;
-    });
-    return manifestKeyMap;
-}

package/dist/esm/node/plugin/plugins/importBuild/index.js

@@ -34,7 +34,7 @@ function importBuild() {
 }
 function getEntryCode(config, configVike) {
     const importPath = getImportPath(config);
-    const vikeManifest = getVikeManifest(config, configVike);
+    const vikeManifest = getVikeManifest(configVike);
     const importerCode = [
         `  import { setImportBuildGetters } from '${importPath}';`,
         `  import * as pageFiles from '${virtualFileIdImportUserCodeServer}';`,

package/dist/esm/node/plugin/plugins/importUserCode/getVirtualFileImportUserCode.js

@@ -1,10 +1,11 @@
 export { getVirtualFileImportUserCode };
-import { assert, assertPosixPath, viteIsSSR_options, isNotNullish, scriptFileExtensions, debugGlob, getOutDirs } from '../../utils.js';
+import { assert, assertPosixPath, viteIsSSR_options, scriptFileExtensions, debugGlob, getOutDirs, isVersionOrAbove, assertWarning } from '../../utils.js';
 import { isVirtualFileIdImportUserCode } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
-import { fileTypes, determineFileType } from '../../../../shared/getPageFiles/fileTypes.js';
+import { version as viteVersion } from 'vite';
+import { fileTypes } from '../../../../shared/getPageFiles/fileTypes.js';
 import path from 'path';
 import { getVirtualFilePageConfigs } from './v1-design/getVirtualFilePageConfigs.js';
-import { generateEagerImport } from './generateEagerImport.js';
+import { isV1Design as isV1Design_ } from './v1-design/getVikeConfig.js';
 async function getVirtualFileImportUserCode(id, options, configVike, config, isDev) {
     const idParsed = isVirtualFileIdImportUserCode(id);
     assert(idParsed);
@@ -21,53 +22,13 @@ async function getCode(config, configVike, isForClientSide, isClientRouting, isP
     assert(isDev === !isBuild);
     let content = '';
     {
-        const globRoots = getGlobRoots(config, configVike);
+        const globRoots = getGlobRoots(config);
         debugGlob('Glob roots: ', globRoots);
         content += await generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, configVike, isPrerendering, config, isDev, id);
     }
-    {
-        const extensionsImportPaths = configVike.extensions
-            .map(({ pageConfigsDistFiles }) => pageConfigsDistFiles)
-            .flat()
-            .filter(isNotNullish)
-            .map(({ importPath }) => importPath);
-        content += generateExtensionImports(extensionsImportPaths, isForClientSide, isBuild, isClientRouting, isPrerendering);
-    }
     debugGlob(`Glob imports for ${isForClientSide ? 'client' : 'server'}:\n`, content);
     return content;
 }
-function generateExtensionImports(extensionsImportPaths, isForClientSide, isBuild, isClientRouting, isPrerendering) {
-    let fileContent = '\n\n';
-    extensionsImportPaths
-        .filter((importPath) => {
-        assert(
-        // V1 design
-        importPath.includes('+') ||
-            // V0.4 design
-            importPath.includes('.page.'));
-        return !importPath.includes('+');
-    })
-        .forEach((importPath) => {
-        const fileType = determineFileType(importPath);
-        const { includeImport, includeExportNames } = determineInjection({
-            fileType,
-            isForClientSide,
-            isClientRouting,
-            isPrerendering,
-            isBuild
-        });
-        if (includeImport) {
-            fileContent += addImport(importPath, fileType, false, isBuild);
-        }
-        if (includeExportNames) {
-            fileContent += addImport(importPath, fileType, true, isBuild);
-        }
-        if (!includeImport && !includeExportNames && !isForClientSide) {
-            fileContent += `pageFilesList.push("${importPath}");` + '\n';
-        }
-    });
-    return fileContent;
-}
 function determineInjection({ fileType, isForClientSide, isClientRouting, isPrerendering, isBuild }) {
     if (!isForClientSide) {
         return {
@@ -93,42 +54,6 @@ function determineInjection({ fileType, isForClientSide, isClientRouting, isPrer
         }
     }
 }
-function addImport(importPath, fileType, exportNames, isBuild) {
-    const pageFilesVar = (() => {
-        if (exportNames) {
-            if (isBuild) {
-                return 'pageFilesExportNamesEager';
-            }
-            else {
-                return 'pageFilesExportNamesLazy';
-            }
-        }
-        else {
-            if (fileType === '.page.route') {
-                return 'pageFilesEager';
-            }
-            else {
-                return 'pageFilesLazy';
-            }
-        }
-    })();
-    const query = !exportNames ? '' : '?extractExportNames';
-    let fileContent = '';
-    const mapVar = `${pageFilesVar}['${fileType}']`;
-    fileContent += `${mapVar} = ${mapVar} ?? {};\n`;
-    const value = (() => {
-        if (!pageFilesVar.endsWith('Eager')) {
-            return `() => import('${importPath}${query}')`;
-        }
-        else {
-            const { importName, importStatement } = generateEagerImport(`${importPath}${query}`);
-            fileContent += importStatement + '\n';
-            return importName;
-        }
-    })();
-    fileContent += `${mapVar}['${importPath}'] = ${value};\n`;
-    return fileContent;
-}
 async function generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, configVike, isPrerendering, config, isDev, id) {
     let fileContent = `// Generatead by node/plugin/plugins/virtualFiles/index.ts
 
@@ -143,6 +68,8 @@ export const isGeneratedFile = true;
 ${await getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRouting, config)}
 
 `;
+    // We still use import.meta.glob() when using th V1 design in order to not break the V1 design deprecation warning
+    const isV1Design = await isV1Design_(config, isDev);
     fileTypes
         .filter((fileType) => fileType !== '.css')
         .forEach((fileType) => {
@@ -155,18 +82,18 @@ ${await getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRouting, c
             isBuild
         });
         if (includeImport) {
-            fileContent += getGlobs(globRoots, isBuild, fileType);
+            fileContent += getGlobs(globRoots, isBuild, fileType, null, isV1Design);
         }
         if (includeExportNames) {
-            fileContent += getGlobs(globRoots, isBuild, fileType, 'extractExportNames');
+            fileContent += getGlobs(globRoots, isBuild, fileType, 'extractExportNames', isV1Design);
         }
     });
     if (configVike.includeAssetsImportedByServer && isForClientSide) {
-        fileContent += getGlobs(globRoots, isBuild, '.page.server', 'extractAssets');
+        fileContent += getGlobs(globRoots, isBuild, '.page.server', 'extractAssets', isV1Design);
     }
     return fileContent;
 }
-function getGlobs(globRoots, isBuild, fileType, query) {
+function getGlobs(globRoots, isBuild, fileType, query, isV1Design) {
     const isEager = isBuild && (query === 'extractExportNames' || fileType === '.page.route');
     let pageFilesVar;
     if (query === 'extractExportNames') {
@@ -206,10 +133,26 @@ function getGlobs(globRoots, isBuild, fileType, query) {
             varNameLocals.push(varNameLocal);
             const globIncludePath = `'${getGlobPath(globRoot.includeDir, fileType)}'`;
             const globExcludePath = globRoot.excludeDir ? `'!${getGlobPath(globRoot.excludeDir, fileType)}'` : null;
-            const globOptions = JSON.stringify({ eager: isEager, as: query });
-            assert(globOptions.startsWith('{"eager":true') || globOptions.startsWith('{"eager":false'));
+            const globOptions = { eager: isEager };
+            if (query) {
+                const isNewViteInterface = isVersionOrAbove(viteVersion, '5.1.0');
+                if (isNewViteInterface &&
+                    // When used for the old design, the new syntax breaks Vike's CI (surprinsigly so). I couldn't reproduce locally (I didn't dig much).
+                    isV1Design) {
+                    globOptions.query = `?${query}`;
+                }
+                else {
+                    globOptions.as = query;
+                    const msg = [
+                        "Update to the new V1 design to get rid of Vite's warning:",
+                        'The glob option "as" has been deprecated in favour of "query".',
+                        'See https://vike.dev/migration/v1-design for how to migrate.'
+                    ].join(' ');
+                    assertWarning(!isNewViteInterface, msg, { onlyOnce: true });
+                }
+            }
             const globPaths = globExcludePath ? `[${globIncludePath}, ${globExcludePath}]` : `[${globIncludePath}]`;
-            const globLine = `const ${varNameLocal} = import.meta.glob(${globPaths}, ${globOptions});`;
+            const globLine = `const ${varNameLocal} = import.meta.glob(${globPaths}, ${JSON.stringify(globOptions)});`;
             return globLine;
         }),
         `const ${varName} = {${varNameLocals.map((varNameLocal) => `...${varNameLocal}`).join(',')}};`,
@@ -217,22 +160,13 @@ function getGlobs(globRoots, isBuild, fileType, query) {
         ''
     ].join('\n');
 }
-function getGlobRoots(config, configVike) {
+function getGlobRoots(config) {
     const globRoots = [
         {
             includeDir: '/',
             excludeDir: path.posix.relative(config.root, getOutDirs(config).outDirRoot)
         }
     ];
-    configVike.extensions
-        .map(({ pageConfigsSrcDir }) => pageConfigsSrcDir)
-        .filter(isNotNullish)
-        .forEach((pageConfigsSrcDir) => {
-        const globRoot = {
-            includeDir: path.posix.relative(config.root, pageConfigsSrcDir)
-        };
-        globRoots.push(globRoot);
-    });
     return globRoots;
 }
 function getGlobPath(globRootDir, fileType) {

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

@@ -33,7 +33,7 @@ function importUserCode() {
         },
         handleHotUpdate(ctx) {
             try {
-                return handleHotUpdate(ctx, config, configVike);
+                return handleHotUpdate(ctx, config);
             }
             catch (err) {
                 // Vite swallows errors thrown by handleHotUpdate()
@@ -57,11 +57,11 @@ function importUserCode() {
         },
         configureServer(server) {
             isDev1_onConfigureServer();
-            handleFileAddRemove(server, config, configVike);
+            handleFileAddRemove(server, config);
         }
     };
 }
-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;
@@ -73,11 +73,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;
     assertPosixPath(file);
     vikeConfigDependencies.forEach((f) => assertPosixPath(f));
@@ -108,7 +108,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;
     }
@@ -116,13 +116,13 @@ function handleHotUpdate(ctx, config, configVike) {
 function isVikeConfigModule(filePathAbsoluteFilesystem) {
     return vikeConfigDependencies.has(filePathAbsoluteFilesystem);
 }
-function reloadConfig(filePath, config, configVike, op) {
+function reloadConfig(filePath, config, op) {
     {
         const filePathToShowToUser = pc.dim(getFilePathRelativeToUserRootDir(filePath, config.root, true));
         const msg = `${op} ${filePathToShowToUser}`;
         logConfigInfo(msg, 'info');
     }
-    reloadVikeConfig(config.root, getOutDirs(config).outDirRoot, configVike.extensions);
+    reloadVikeConfig(config.root, getOutDirs(config).outDirRoot);
 }
 function getVirtualModules(server) {
     const virtualModules = Array.from(server.moduleGraph.urlToModuleMap.keys())

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

@@ -60,15 +60,7 @@ function getConfigValueSerialized(value, configName, definedAt) {
         */
         const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser({ definedAt });
         assert(configValueFilePathToShowToUser);
-        assertUsage(false, [
-            `The code of ${pc.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(' '));
+        assertUsage(false, `${pc.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/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js

@@ -88,6 +88,9 @@ const configDefinitionsBuiltIn = {
     },
     cacheControl: {
         env: { server: true }
+    },
+    name: {
+        env: { config: true }
     }
 };
 const configDefinitionsBuiltInGlobal = {

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

@@ -13,18 +13,18 @@ export { getLogicalPath };
  * Each config value is assigned with a `locationId` value. That's the source-of-truth for determining inheritance between config values.
  *
  * For Vike extensions, `locationId` is different than the config value's `definedAt`, for example the `onRenderHtml()` hook of `vike-react`:
- *  - `locationId === '/pages'` (the directory of `/pages/+config.h.js` which extends `vike-react`)
+ *  - `locationId === '/pages'` (the directory of `/pages/+config.js` which extends `vike-react`)
  *  - `definedAt.filePathAbsoluteFilesystem === '/home/rom/code/my-vike-app/node_modules/vike-react/dist/renderer/onRenderHtml.js'` (the file where the value is defined)
  *
  *  This is an important distinction because the Vike extension's config should only apply to where it's being extended from, for example:
  *  ```js
- *  // /pages/admin/+config.h.js
+ *  // /pages/admin/+config.js
  *  import vikeVue from 'vike-vue/config'
  *  // Should only apply to /pages/admin/**
  *  export default { extends: [vikeVue] }
  *  ```
  *  ```js
- *  // /pages/marketing/+config.h.js
+ *  // /pages/marketing/+config.js
  *  import vikeReact from 'vike-react/config'
  *  // Should only apply to /pages/marketing/**
  *  export default { extends: [vikeReact] }

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

@@ -15,7 +15,7 @@ import { assert, assertPosixPath, higherFirst } from '../../../../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) {
     assertPosixPath(filePathRelativeToUserRootDir);
     assert(filePathRelativeToUserRootDir.startsWith('/'));

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

@@ -15,7 +15,7 @@ declare function loadImportedFile(import_: FilePathResolved & {
     fileExportName: string;
 }, userRootDir: string, importedFilesLoaded: ImportedFilesLoaded): Promise<unknown>;
 declare function loadValueFile(interfaceValueFile: InterfaceValueFile, configName: string, userRootDir: string): Promise<void>;
-declare function loadConfigFile(configFilePath: FilePathResolved, userRootDir: string, visited: string[], isConfigOfExtension: boolean): Promise<{
+declare function loadConfigFile(configFilePath: FilePathResolved, userRootDir: string, visited: string[], isExtensionConfig: boolean): Promise<{
     configFile: ConfigFile;
     extendsConfigs: ConfigFile[];
 }>;

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

@@ -14,7 +14,7 @@ assertIsNotProductionRuntime();
 async function loadImportedFile(import_, userRootDir, importedFilesLoaded) {
     const f = import_.filePathAbsoluteFilesystem;
     if (!importedFilesLoaded[f]) {
-        importedFilesLoaded[f] = transpileAndExecuteFile(import_, false, userRootDir).then((r) => r.fileExports);
+        importedFilesLoaded[f] = transpileAndExecuteFile(import_, userRootDir, false).then((r) => r.fileExports);
     }
     const fileExports = await importedFilesLoaded[f];
     const fileExport = fileExports[import_.fileExportName];
@@ -22,7 +22,7 @@ async function loadImportedFile(import_, userRootDir, importedFilesLoaded) {
 }
 // Load +{configName}.js
 async function loadValueFile(interfaceValueFile, configName, userRootDir) {
-    const { fileExports } = await transpileAndExecuteFile(interfaceValueFile.filePath, false, userRootDir);
+    const { fileExports } = await transpileAndExecuteFile(interfaceValueFile.filePath, userRootDir, false);
     const { filePathToShowToUser } = interfaceValueFile.filePath;
     assertPlusFileExport(fileExports, filePathToShowToUser, configName);
     Object.entries(fileExports).forEach(([exportName, configValue]) => {
@@ -31,10 +31,10 @@ async function loadValueFile(interfaceValueFile, configName, userRootDir) {
     });
 }
 // 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 transpileAndExecuteFile(configFilePath, !isConfigOfExtension, userRootDir, isConfigOfExtension);
+    const { fileExports } = await transpileAndExecuteFile(configFilePath, userRootDir, isExtensionConfig ? 'is-extension-config' : true);
     const { extendsConfigs, extendsFilePaths } = await loadExtendsConfigs(fileExports, configFilePath, userRootDir, [
         ...visited,
         filePathAbsoluteFilesystem

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

@@ -115,7 +115,7 @@ function assertFileEnv(filePathForEnvCheck, configEnv, configName) {
         assertUsage(false, [
             `${filePathForEnvCheck} 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))}`),
-            '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/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transformFileImports.d.ts

@@ -1,20 +1,8 @@
 export { transformFileImports };
 export { parseImportData };
 export { isImportData };
-export type { FileImport };
 export type { ImportData };
-type FileImport = {
-    importStatementCode: string;
-    importString: string;
-    importLocalName: string;
-};
-declare function transformFileImports(code: string, filePathToShowToUser2: string, skipWarnings?: true): {
-    noTransformation: true;
-} | {
-    noTransformation: false;
-    code: string;
-    fileImportsTransformed: FileImport[];
-};
+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'`