vike 0.4.143 → 0.4.144-commit-e40e9b1

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

@@ -1,3 +1,3 @@
 export { getVirtualFilePageConfigValuesAll };
 import type { ConfigVikeResolved } from '../../../../../shared/ConfigVike.js';
-declare function getVirtualFilePageConfigValuesAll(id: string, userRootDir: string, isDev: boolean, configVike: ConfigVikeResolved): Promise<string>;
+declare function getVirtualFilePageConfigValuesAll(id: string, userRootDir: string, outDirRoot: string, isDev: boolean, configVike: ConfigVikeResolved): Promise<string>;

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

@@ -1,15 +1,14 @@
 export { getVirtualFilePageConfigValuesAll };
-import { assert, assertPosixPath } from '../../../utils.js';
-import { generateEagerImport } from '../generateEagerImport.js';
+import { assert } from '../../../utils.js';
 import { getVirtualFileIdPageConfigValuesAll, isVirtualFileIdPageConfigValuesAll } from '../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { getVikeConfig } from './getVikeConfig.js';
 import { extractAssetsAddQuery } from '../../../../shared/extractAssetsQuery.js';
 import { debug } from './debug.js';
-import path from 'path';
 import { getConfigValue } from '../../../../../shared/page-configs/utils.js';
-import { getConfigValueSourcesRelevant } from '../../../shared/getConfigValueSource.js';
-import { isConfigEnvMatch } from './isConfigEnvMatch.js';
-async function getVirtualFilePageConfigValuesAll(id, userRootDir, isDev, configVike) {
+import { getConfigValueSourcesRelevant } from '../../../shared/getConfigValueSourcesRelevant.js';
+import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
+import { serializeConfigValueImported } from '../../../../../shared/page-configs/serialize/serializeConfigValue.js';
+async function getVirtualFilePageConfigValuesAll(id, userRootDir, outDirRoot, isDev, configVike) {
     const result = isVirtualFileIdPageConfigValuesAll(id);
     assert(result);
     /* This assertion fails when using includeAssetsImportedByServer
@@ -19,7 +18,7 @@ async function getVirtualFilePageConfigValuesAll(id, userRootDir, isDev, configV
     }
     */
     const { pageId, isForClientSide } = result;
-    const { pageConfigs } = await getVikeConfig(userRootDir, isDev, configVike.extensions, true);
+    const { pageConfigs } = await getVikeConfig(userRootDir, outDirRoot, isDev, configVike.extensions, true);
     const pageConfig = pageConfigs.find((pageConfig) => pageConfig.pageId === pageId);
     assert(pageConfig);
     const code = getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, configVike.includeAssetsImportedByServer, isDev);
@@ -32,37 +31,17 @@ function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAsse
     const lines = [];
     const importStatements = [];
     lines.push('export default [');
-    let varCounter = 0;
+    const varCounterContainer = { varCounter: 0 };
     getConfigValueSourcesRelevant(pageConfig).forEach((configValueSource) => {
-        const { valueIsImportedAtRuntime, configName, configEnv, definedAtInfo } = configValueSource;
+        const { valueIsImportedAtRuntime, configEnv, configName } = configValueSource;
         if (!valueIsImportedAtRuntime)
             return;
         if (configValueSource.valueIsFilePath)
             return;
-        if (!isConfigEnvMatch(configEnv, isForClientSide, isClientRouting))
+        if (!isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isEager: false }))
             return;
-        const { filePath, fileExportPath } = definedAtInfo;
-        assertPosixPath(filePath);
-        const fileName = path.posix.basename(filePath);
-        const isPlusFile = fileName.startsWith('+');
-        const fileExportName = fileExportPath[0];
-        assert(!configValueSource.valueIsFilePath);
-        assert(fileExportName);
-        const { importVar, importStatement } = generateEagerImport(filePath, varCounter++, isPlusFile ? undefined : fileExportName);
-        importStatements.push(importStatement);
-        lines.push(`  {`);
-        lines.push(`    configName: '${configName}',`);
-        lines.push(`    importFilePath: '${filePath}',`);
-        lines.push(`    isPlusFile: ${JSON.stringify(isPlusFile)},`);
-        if (isPlusFile) {
-            lines.push(`    importFileExports: ${importVar},`);
-        }
-        else {
-            lines.push(`    importFileExportValue: ${importVar},`);
-            assert(fileExportName);
-            lines.push(`    importFileExportName: ${JSON.stringify(fileExportName)},`);
-        }
-        lines.push(`  },`);
+        const whitespace = '  ';
+        lines.push(...serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements));
     });
     lines.push('];');
     if (includeAssetsImportedByServer && isForClientSide && !isDev) {

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

@@ -1,6 +1,6 @@
 export { getVirtualFilePageConfigs };
 export { getConfigValueSerialized };
-import type { DefinedAtInfo } from '../../../../../shared/page-configs/PageConfig.js';
+import type { DefinedAt } from '../../../../../shared/page-configs/PageConfig.js';
 import type { ConfigVikeResolved } from '../../../../../shared/ConfigVike.js';
-declare function getVirtualFilePageConfigs(userRootDir: string, isForClientSide: boolean, isDev: boolean, id: string, configVike: ConfigVikeResolved, isClientRouting: boolean): Promise<string>;
-declare function getConfigValueSerialized(value: unknown, configName: string, definedAtInfo: null | DefinedAtInfo): string;
+declare function getVirtualFilePageConfigs(userRootDir: string, outDirRoot: string, isForClientSide: boolean, isDev: boolean, id: string, configVike: ConfigVikeResolved, isClientRouting: boolean): Promise<string>;
+declare function getConfigValueSerialized(value: unknown, configName: string, definedAt: DefinedAt): string;

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

@@ -1,22 +1,24 @@
 export { getVirtualFilePageConfigs };
 export { getConfigValueSerialized };
 import { assert, assertUsage, getPropAccessNotation, hasProp, objectEntries } from '../../../utils.js';
-import { generateEagerImport } from '../generateEagerImport.js';
 import { getVirtualFileIdPageConfigValuesAll } from '../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { debug } from './debug.js';
 import { stringify } from '@brillout/json-serializer/stringify';
 import { getConfigEnv } from './helpers.js';
 import pc from '@brillout/picocolors';
 import { getVikeConfig } from './getVikeConfig.js';
-import { isConfigEnvMatch } from './isConfigEnvMatch.js';
-async function getVirtualFilePageConfigs(userRootDir, isForClientSide, isDev, id, configVike, isClientRouting) {
-    const { pageConfigs, pageConfigGlobal } = await getVikeConfig(userRootDir, isDev, configVike.extensions, true);
+import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
+import { getConfigValueFilePathToShowToUser } from '../../../../../shared/page-configs/utils.js';
+import { serializeConfigValue, serializeConfigValueImported } from '../../../../../shared/page-configs/serialize/serializeConfigValue.js';
+async function getVirtualFilePageConfigs(userRootDir, outDirRoot, isForClientSide, isDev, id, configVike, isClientRouting) {
+    const { pageConfigs, pageConfigGlobal } = await getVikeConfig(userRootDir, outDirRoot, isDev, configVike.extensions, true);
     return getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
 }
 function getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting) {
     const lines = [];
     const importStatements = [];
-    lines.push('export const pageConfigs = [');
+    const varCounterContainer = { varCounter: 0 };
+    lines.push('export const pageConfigsSerialized = [');
     pageConfigs.forEach((pageConfig) => {
         const { pageId, routeFilesystem, isErrorPage } = pageConfig;
         const virtualFileIdPageConfigValuesAll = getVirtualFileIdPageConfigValuesAll(pageId, isForClientSide);
@@ -25,133 +27,96 @@ function getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, i
         lines.push(`    isErrorPage: ${JSON.stringify(isErrorPage)},`);
         lines.push(`    routeFilesystem: ${JSON.stringify(routeFilesystem)},`);
         lines.push(`    loadConfigValuesAll: async () => (await import(${JSON.stringify(virtualFileIdPageConfigValuesAll)})).default,`);
-        lines.push(`    configValues: {`);
-        Object.entries(pageConfig.configValueSources).forEach(([configName, sources]) => {
+        lines.push(`    configValuesSerialized: {`);
+        Object.entries(pageConfig.configValuesComputed).forEach(([configName, configValuesComputed]) => {
+            const { value, configEnv } = configValuesComputed;
+            if (!isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isEager: true }))
+                return;
+            if (pageConfig.configValueSources[configName])
+                return;
+            const configValue = pageConfig.configValues[configName];
+            assert(configValue);
+            const { definedAt } = configValue;
+            const valueSerialized = getConfigValueSerialized(value, configName, definedAt);
+            serializeConfigValue(lines, configName, { definedAt, valueSerialized });
+        });
+        Object.entries(pageConfig.configValueSources).forEach(([configName]) => {
             const configValue = pageConfig.configValues[configName];
             if (configValue) {
-                const configEnv = getConfigEnv(pageConfig, configName);
+                const configEnv = getConfigEnv(pageConfig.configValueSources, configName);
                 assert(configEnv, configName);
-                if (!isConfigEnvMatch(configEnv, isForClientSide, isClientRouting))
+                const isEnvMatch = isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isEager: true });
+                if (!isEnvMatch)
                     return;
-                const { value, definedAtInfo } = configValue;
-                const valueSerialized = getConfigValueSerialized(value, configName, definedAtInfo);
-                const configValue2 = { definedAtInfo, valueSerialized };
-                serializeConfigValue(lines, configName, configValue2);
-            }
-            else {
-                const configValueSource = sources[0];
-                assert(configValueSource);
-                if (configValueSource.configEnv === '_routing-eager') {
-                    const { definedAtInfo } = configValueSource;
-                    assert(!configValueSource.isComputed);
-                    const { filePath, fileExportPath } = configValueSource.definedAtInfo;
-                    const [exportName] = fileExportPath;
-                    assert(exportName);
-                    const configValueEagerImport = getConfigValueEagerImport(filePath, exportName, importStatements);
-                    const configValue = { definedAtInfo, value: configValueEagerImport };
-                    serializeConfigValue(lines, configName, configValue);
-                }
+                const { value, definedAt } = configValue;
+                const valueSerialized = getConfigValueSerialized(value, configName, definedAt);
+                serializeConfigValue(lines, configName, { definedAt, valueSerialized });
             }
         });
         lines.push(`    },`);
+        let whitespace = '    ';
+        lines.push(`${whitespace}configValuesImported: [`);
+        Object.entries(pageConfig.configValueSources).forEach(([configName, sources]) => {
+            const configValue = pageConfig.configValues[configName];
+            if (configValue)
+                return;
+            const configValueSource = sources[0];
+            assert(configValueSource);
+            if (configValueSource.configEnv !== '_routing-eager')
+                return;
+            lines.push(...serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements));
+        });
+        lines.push(`${whitespace}],`);
+        // pageConfig end
         lines.push(`  },`);
     });
     lines.push('];');
-    lines.push('export const pageConfigGlobal = {');
-    objectEntries(pageConfigGlobal).forEach(([configName, configValueSource]) => {
+    lines.push('export const pageConfigGlobalSerialized = {');
+    /* Nothing (yet)
+    lines.push(`  configValuesSerialized: {`)
+    lines.push(`  },`)
+    */
+    lines.push(`  configValuesImported: [`);
+    objectEntries(pageConfigGlobal.configValueSources).forEach(([configName, sources]) => {
         if (configName === 'onBeforeRoute') {
             // if( isForClientSide && !isClientRouting ) return
         }
         else if (configName === 'onPrerenderStart') {
             if (isDev || isForClientSide) {
                 // Only load onPrerenderStart() in server production runtime
-                configValueSource = null;
+                return;
             }
         }
         else {
             assert(false);
         }
-        let whitespace = '  ';
-        let content;
-        if (configValueSource === null) {
-            content = 'null,';
-        }
-        else {
-            content = serializeConfigValueSource(configValueSource, configName, whitespace, isForClientSide, isClientRouting, importStatements, true);
-            assert(content.startsWith('{') && content.endsWith('},') && content.includes('\n'));
-        }
-        content = `${whitespace}[${JSON.stringify(configName)}]: ${content}`;
-        lines.push(content);
+        const configValueSource = sources[0];
+        assert(configValueSource);
+        const whitespace = '    ';
+        lines.push(...serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements));
     });
+    lines.push(`  ],`);
     lines.push('};');
     const code = [...importStatements, ...lines].join('\n');
     debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
     return code;
 }
-function serializeConfigValue(lines, configName, configValue) {
-    let whitespace = '      ';
-    lines.push(`${whitespace}['${configName}']: {`);
-    whitespace += '  ';
-    Object.entries(configValue).forEach(([key, val]) => {
-        const valSerialized = key === 'value' || key === 'valueSerialized' ? val : JSON.stringify(val);
-        lines.push(`${whitespace}  ${key}: ${valSerialized},`);
-    });
-    whitespace = whitespace.slice(2);
-    lines.push(`${whitespace}},`);
-}
-function serializeConfigValueSource(configValueSource, configName, whitespace, isForClientSide, isClientRouting, importStatements, isGlobalConfig) {
-    assert(!configValueSource.isComputed);
-    const { definedAtInfo, configEnv } = configValueSource;
-    const lines = [];
-    lines.push(`{`);
-    lines.push(`${whitespace}  definedAtInfo: ${JSON.stringify(definedAtInfo)},`);
-    lines.push(`${whitespace}  configEnv: ${JSON.stringify(configEnv)},`);
-    const eager = configValueSource.configEnv === '_routing-eager' || isGlobalConfig;
-    if (isConfigEnvMatch(configEnv, isForClientSide, isClientRouting) || eager) {
-        if ('value' in configValueSource) {
-            const { value } = configValueSource;
-            const valueSerialized = getConfigValueSerialized(value, configName, definedAtInfo);
-            lines.push(`${whitespace}  valueSerialized: ${valueSerialized}`);
-        }
-        else if (eager) {
-            const { filePath, fileExportPath } = configValueSource.definedAtInfo;
-            const [exportName] = fileExportPath;
-            assert(exportName);
-            const configValueEagerImport = getConfigValueEagerImport(filePath, exportName, importStatements);
-            lines.push(`${whitespace}  value: ${configValueEagerImport},`);
-        }
-    }
-    lines.push(`${whitespace}},`);
-    return lines.join('\n');
-}
-function getConfigValueSerialized(value, configName, definedAtInfo) {
-    let configValueSerialized;
+function getConfigValueSerialized(value, configName, definedAt) {
     const valueName = `config${getPropAccessNotation(configName)}`;
+    let configValueSerialized;
     try {
         configValueSerialized = stringify(value, { valueName });
     }
     catch (err) {
         assert(hasProp(err, 'messageCore', 'string'));
-        // definedAtInfo is null when config value is:
-        //  - computed => all computed values defined by Vike can are serializable
-        //  - cumulative => the values are already ensured to be serializable
-        assert(definedAtInfo);
-        const configDefinedByFile = definedAtInfo.filePath;
-        assert(configDefinedByFile);
+        const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser({ definedAt });
+        assert(configValueFilePathToShowToUser);
         assertUsage(false, [
-            `The value of the config ${pc.cyan(configName)} cannot be defined inside the file ${configDefinedByFile}:`,
-            `its value must be defined in an another file and then imported by ${configDefinedByFile}. (Because the value isn't serializable: ${err.messageCore}.)`,
+            `The value of the config ${pc.cyan(configName)} cannot be defined inside the file ${configValueFilePathToShowToUser}:`,
+            `its value must be defined in an another file and then imported by ${configValueFilePathToShowToUser}. (Because the value isn't serializable: ${err.messageCore}.)`,
             `Only serializable config values can be defined inside +config.h.js files, see https://vike.dev/header-file.`
         ].join(' '));
     }
     configValueSerialized = JSON.stringify(configValueSerialized);
     return configValueSerialized;
 }
-function getConfigValueEagerImport(importFilePath, exportName, importStatements) {
-    let configValueEagerImport;
-    const { importVar, importStatement } = generateEagerImport(importFilePath);
-    importStatements.push(importStatement);
-    // TODO: expose all exports so that assertDefaultExport can be applied
-    configValueEagerImport = `${importVar}[${JSON.stringify(exportName)}]`;
-    return configValueEagerImport;
-}

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

@@ -1,5 +1,5 @@
 export { getConfigEnv };
 export { isConfigSet };
-import type { ConfigEnvInternal, PageConfigBuildTime } from '../../../../../shared/page-configs/PageConfig.js';
-declare function getConfigEnv(pageConfig: PageConfigBuildTime, configName: string): null | ConfigEnvInternal;
-declare function isConfigSet(pageConfig: PageConfigBuildTime, configName: string): boolean;
+import type { ConfigEnvInternal, ConfigValueSources } from '../../../../../shared/page-configs/PageConfig.js';
+declare function getConfigEnv(configValueSources: ConfigValueSources, configName: string): null | ConfigEnvInternal;
+declare function isConfigSet(configValueSources: ConfigValueSources, configName: string): boolean;

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

@@ -1,10 +1,9 @@
 export { getConfigEnv };
 export { isConfigSet };
-import { getConfigValueSource } from '../../../shared/getConfigValueSource.js';
 import { assert, assertIsNotProductionRuntime } from '../../../utils.js';
 assertIsNotProductionRuntime();
-function getConfigEnv(pageConfig, configName) {
-    const configValueSource = getConfigValueSource(pageConfig, configName);
+function getConfigEnv(configValueSources, configName) {
+    const configValueSource = getConfigValueSource(configValueSources, configName);
     if (!configValueSource)
         return null;
     if (configValueSource) {
@@ -22,10 +21,18 @@ function getConfigEnv(pageConfig, configName) {
         */
     }
 }
-function isConfigSet(pageConfig, configName) {
-    const configValueSource = getConfigValueSource(pageConfig, configName);
+function isConfigSet(configValueSources, configName) {
+    const configValueSource = getConfigValueSource(configValueSources, configName);
     // Enable users to suppress global config values by overriding the config's value to null
     if (configValueSource?.value === null)
         return false;
     return !!configValueSource;
 }
+function getConfigValueSource(configValueSources, configName) {
+    const sources = configValueSources[configName];
+    if (!sources)
+        return null;
+    const configValueSource = sources[0];
+    assert(configValueSource);
+    return configValueSource;
+}

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

@@ -0,0 +1,7 @@
+export { isRuntimeEnvMatch };
+import type { ConfigEnvInternal } from '../../../../../shared/page-configs/PageConfig.js';
+declare function isRuntimeEnvMatch(configEnv: ConfigEnvInternal, runtime: {
+    isForClientSide: boolean;
+    isClientRouting: boolean;
+    isEager: boolean;
+}): boolean;

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

@@ -0,0 +1,15 @@
+export { isRuntimeEnvMatch };
+function isRuntimeEnvMatch(configEnv, runtime) {
+    const { isForClientSide, isClientRouting, isEager } = runtime;
+    if (configEnv === 'config-only')
+        return false;
+    if (configEnv === (isForClientSide ? 'server-only' : 'client-only'))
+        return false;
+    if (configEnv === '_routing-eager' || configEnv === '_routing-lazy') {
+        if (isForClientSide && !isClientRouting)
+            return false;
+        if (isEager !== (configEnv === '_routing-eager'))
+            return false;
+    }
+    return true;
+}

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

@@ -5,7 +5,7 @@ export type { FileImport };
 export type { ImportData };
 type FileImport = {
     importStatementCode: string;
-    importDataString: string;
+    importString: string;
     importLocalName: string;
 };
 declare function replaceImportStatements(code: string, filePathToShowToUser: string): {
@@ -15,14 +15,26 @@ declare function replaceImportStatements(code: string, filePathToShowToUser: str
     code: string;
     fileImports: FileImport[];
 };
+/**
+ * Data Structure holding info about import statement:
+ *   `import { someExport as someImport } from './some-file'`
+ * <=>
+ *   `importData === {`
+ *      `importPath: './some-file',`
+ *      `exportName: 'someExport',`
+ *      `importString: 'import:./some-file:someExport',`
+ *      `importStringWasGenerated: true,`
+ *    `}`
+ * We discard the import name `someImport` because we don't need it.
+ */
 type ImportData = {
-    importFilePath: string;
-    importFileExportName: string;
-    importWasGenerated: boolean;
-    importDataString: string;
+    importPath: string;
+    exportName: string;
+    importString: string;
+    importStringWasGenerated: boolean;
 };
 declare function isImportData(str: string): boolean;
-declare function parseImportData(importDataString: string): null | ImportData;
+declare function parseImportData(importString: string): null | ImportData;
 declare module 'estree' {
     interface BaseNodeWithoutComments {
         start: number;

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

@@ -14,13 +14,13 @@ function replaceImportStatements(code, filePathToShowToUser) {
     imports.forEach((node) => {
         if (node.type !== 'ImportDeclaration')
             return;
-        const importFilePath = node.source.value;
-        assert(typeof importFilePath === 'string');
+        const importPath = node.source.value;
+        assert(typeof importPath === 'string');
         const { start, end } = node;
         const importStatementCode = code.slice(start, end);
         // No variable imported
         if (node.specifiers.length === 0) {
-            const isWarning = !styleFileRE.test(importFilePath);
+            const isWarning = !styleFileRE.test(importPath);
             let quote = indent(importStatementCode);
             if (isWarning) {
                 quote = pc.cyan(quote);
@@ -43,7 +43,7 @@ function replaceImportStatements(code, filePathToShowToUser) {
                 specifier.type === 'ImportDefaultSpecifier' ||
                 specifier.type === 'ImportNamespaceSpecifier');
             const importLocalName = specifier.local.name;
-            const importFileExportName = (() => {
+            const exportName = (() => {
                 if (specifier.type === 'ImportDefaultSpecifier')
                     return 'default';
                 if (specifier.type === 'ImportNamespaceSpecifier')
@@ -55,11 +55,11 @@ function replaceImportStatements(code, filePathToShowToUser) {
                 }
                 return importLocalName;
             })();
-            const importDataString = serializeImportData({ importFilePath, importFileExportName, importWasGenerated: true });
-            replacement += `const ${importLocalName} = '${importDataString}';`;
+            const importString = serializeImportData({ importPath, exportName, importStringWasGenerated: true });
+            replacement += `const ${importLocalName} = '${importString}';`;
             fileImports.push({
                 importStatementCode,
-                importDataString,
+                importString,
                 importLocalName
             });
         });
@@ -88,34 +88,34 @@ function getImports(code) {
 const import_ = 'import';
 const SEP = ':';
 const zeroWidthSpace = '\u200b';
-function serializeImportData({ importFilePath, importFileExportName, importWasGenerated }) {
-    const tag = importWasGenerated ? zeroWidthSpace : '';
-    // `import:${importFilePath}:${importFilePath}`
-    return `${tag}${import_}${SEP}${importFilePath}${SEP}${importFileExportName}`;
+function serializeImportData({ importPath, exportName, importStringWasGenerated }) {
+    const tag = importStringWasGenerated ? zeroWidthSpace : '';
+    // `import:${importPath}:${importPath}`
+    return `${tag}${import_}${SEP}${importPath}${SEP}${exportName}`;
 }
 function isImportData(str) {
     return str.startsWith(import_ + SEP) || str.startsWith(zeroWidthSpace + import_ + SEP);
 }
-function parseImportData(importDataString) {
-    if (!isImportData(importDataString)) {
+function parseImportData(importString) {
+    if (!isImportData(importString)) {
         return null;
     }
-    let importWasGenerated = false;
-    if (importDataString.startsWith(zeroWidthSpace)) {
-        importWasGenerated = true;
+    let importStringWasGenerated = false;
+    if (importString.startsWith(zeroWidthSpace)) {
+        importStringWasGenerated = true;
         assert(zeroWidthSpace.length === 1);
-        importDataString = importDataString.slice(1);
+        importString = importString.slice(1);
     }
-    const parts = importDataString.split(SEP).slice(1);
-    if (!importWasGenerated && parts.length === 1) {
-        const importFileExportName = 'default';
-        const importFilePath = parts[0];
-        return { importFilePath, importFileExportName, importWasGenerated, importDataString };
+    const parts = importString.split(SEP).slice(1);
+    if (!importStringWasGenerated && parts.length === 1) {
+        const exportName = 'default';
+        const importPath = parts[0];
+        return { importPath, exportName, importStringWasGenerated, importString };
     }
     assert(parts.length >= 2);
-    const importFileExportName = parts[parts.length - 1];
-    const importFilePath = parts.slice(0, -1).join(SEP);
-    return { importFilePath, importFileExportName, importWasGenerated, importDataString };
+    const exportName = parts[parts.length - 1];
+    const importPath = parts.slice(0, -1).join(SEP);
+    return { importPath, exportName, importStringWasGenerated, importString };
 }
 function spliceMany(str, operations) {
     let strMod = '';

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

@@ -1,6 +1,6 @@
 export { transpileAndExecuteFile };
 export { getConfigBuildErrorFormatted };
-export { getConfigExececutionErrorIntroMsg };
+export { getConfigExecutionErrorIntroMsg as getConfigExecutionErrorIntroMsg };
 export { isTmpFile };
 import 'source-map-support/register.js';
 import { type FilePath } from './getFilePathToShowToUser.js';
@@ -8,5 +8,5 @@ declare function transpileAndExecuteFile(filePath: FilePath, isValueFile: boolea
     fileExports: Record<string, unknown>;
 }>;
 declare function getConfigBuildErrorFormatted(err: unknown): null | string;
-declare function getConfigExececutionErrorIntroMsg(err: unknown): string | null;
+declare function getConfigExecutionErrorIntroMsg(err: unknown): string | null;
 declare function isTmpFile(filePath: string): boolean;

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

@@ -1,21 +1,22 @@
 export { transpileAndExecuteFile };
 export { getConfigBuildErrorFormatted };
-export { getConfigExececutionErrorIntroMsg };
+export { getConfigExecutionErrorIntroMsg as getConfigExecutionErrorIntroMsg };
 export { isTmpFile };
 import { build, formatMessages } from 'esbuild';
 import fs from 'fs';
 import path from 'path';
 import pc from '@brillout/picocolors';
 import { import_ } from '@brillout/import';
-import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, assertDefaultExportObject, unique, assertWarning, isObject, toPosixPath, assertUsage } from '../../../utils.js';
+import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, unique, assertWarning, isObject, toPosixPath, assertUsage } from '../../../utils.js';
 import { isImportData, replaceImportStatements } from './replaceImportStatements.js';
 import { vikeConfigDependencies } from './getVikeConfig.js';
 import 'source-map-support/register.js';
 import { getFilePathToShowToUser } from './getFilePathToShowToUser.js';
+import { assertExportsOfConfigFile } from '../../../../../shared/page-configs/assertExports.js';
 assertIsNotProductionRuntime();
 async function transpileAndExecuteFile(filePath, isValueFile, userRootDir) {
     const { code, fileImports } = await transpileFile(filePath, isValueFile, userRootDir);
-    const { fileExports } = await executeFile(filePath, code, fileImports);
+    const { fileExports } = await executeFile(filePath, code, fileImports, isValueFile);
     return { fileExports };
 }
 async function transpileFile(filePath, isValueFile, userRootDir) {
@@ -132,7 +133,7 @@ async function transpileWithEsbuild(filePath, bundle, userRootDir) {
     assert(typeof code === 'string');
     return code;
 }
-async function executeFile(filePath, code, fileImports) {
+async function executeFile(filePath, code, fileImports, isValueFile) {
     const { filePathAbsolute, filePathRelativeToUserRootDir } = 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
@@ -157,10 +158,10 @@ async function executeFile(filePath, code, fileImports) {
     //  - import() returns `[Module: null prototype] { default: { onRenderClient: '...' }}`
     //  - We don't need this special object
     fileExports = { ...fileExports };
-    if (fileImports) {
+    if (fileImports && !isValueFile) {
         assert(filePathRelativeToUserRootDir !== undefined);
-        const filePath = filePathRelativeToUserRootDir ?? filePathAbsolute;
-        assertFileImports(fileImports, fileExports, filePath);
+        const filePathToShowToUser = filePathRelativeToUserRootDir ?? filePathAbsolute;
+        assertImportsAreReExported(fileImports, fileExports, filePathToShowToUser);
     }
     return { fileExports };
 }
@@ -185,7 +186,7 @@ async function formatBuildErr(err, filePath) {
     err[formatted] = `${msgIntro}\n${msgEsbuild}`;
 }
 const execErrIntroMsg = new WeakMap();
-function getConfigExececutionErrorIntroMsg(err) {
+function getConfigExecutionErrorIntroMsg(err) {
     if (!isObject(err))
         return null;
     const errIntroMsg = execErrIntroMsg.get(err);
@@ -206,17 +207,17 @@ function isTmpFile(filePath) {
     const fileName = path.posix.basename(filePath);
     return fileName.startsWith(tmpPrefix);
 }
-function assertFileImports(fileImports, fileExports, filePath) {
-    assertDefaultExportObject(fileExports, filePath);
+function assertImportsAreReExported(fileImports, fileExports, filePathToShowToUser) {
+    assertExportsOfConfigFile(fileExports, filePathToShowToUser);
     const exportedStrings = getExportedStrings(fileExports.default);
     Object.values(exportedStrings).forEach((exportVal) => {
         if (typeof exportVal !== 'string')
             return;
         if (!isImportData(exportVal))
             return;
-        const importDataString = exportVal;
+        const importString = exportVal;
         fileImports.forEach((fileImport) => {
-            if (fileImport.importDataString === importDataString) {
+            if (fileImport.importString === importString) {
                 fileImport.isReExported = true;
             }
         });
@@ -228,7 +229,7 @@ function assertFileImports(fileImports, fileExports, filePath) {
     const importNamesUnused = fileImportsUnused.map((fi) => pc.cyan(fi.importLocalName)).join(', ');
     const singular = fileImportsUnused.length === 1;
     assertUsage(fileImportsUnused.length === 0, [
-        `${filePath} imports the following:`,
+        `${filePathToShowToUser} imports the following:`,
         ...importStatements.map((s) => pc.cyan(`  ${s}`)),
         `But the import${singular ? '' : 's'} ${importNamesUnused} ${singular ? "isn't" : "aren't"} re-exported at ${pc.cyan('export default { ... }')} and therefore ${singular ? 'has' : 'have'} no effect, see explanation at https://vike.dev/header-file`
     ].join('\n'));

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

@@ -1,11 +1,12 @@
 export { findPageFiles };
 import glob from 'fast-glob';
-import { assertWarning, toPosixPath, scriptFileExtensions } from '../utils.js';
+import { assertWarning, toPosixPath, scriptFileExtensions, getOutDirs } from '../utils.js';
 import pc from '@brillout/picocolors';
 async function findPageFiles(config, fileTypes, isDev) {
     const cwd = config.root;
+    const { outDirRoot } = getOutDirs(config);
     const timeBase = new Date().getTime();
-    let pageFiles = await glob(fileTypes.map((fileType) => `**/*${fileType}.${scriptFileExtensions}`), { ignore: ['**/node_modules/**'], cwd, dot: false });
+    let pageFiles = await glob(fileTypes.map((fileType) => `**/*${fileType}.${scriptFileExtensions}`), { ignore: ['**/node_modules/**', `${outDirRoot}/**`], cwd, dot: false });
     pageFiles = pageFiles.map((p) => '/' + toPosixPath(p));
     const time = new Date().getTime() - timeBase;
     if (isDev) {