vike 0.4.143 → 0.4.144-commit-e40e9b1

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

@@ -1,20 +1,16 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getVirtualFilePageConfigValuesAll = void 0;
 const utils_js_1 = require("../../../utils.js");
-const generateEagerImport_js_1 = require("../generateEagerImport.js");
 const virtualFilePageConfigValuesAll_js_1 = require("../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js");
 const getVikeConfig_js_1 = require("./getVikeConfig.js");
 const extractAssetsQuery_js_1 = require("../../../../shared/extractAssetsQuery.js");
 const debug_js_1 = require("./debug.js");
-const path_1 = __importDefault(require("path"));
 const utils_js_2 = require("../../../../../shared/page-configs/utils.js");
-const getConfigValueSource_js_1 = require("../../../shared/getConfigValueSource.js");
-const isConfigEnvMatch_js_1 = require("./isConfigEnvMatch.js");
-async function getVirtualFilePageConfigValuesAll(id, userRootDir, isDev, configVike) {
+const getConfigValueSourcesRelevant_js_1 = require("../../../shared/getConfigValueSourcesRelevant.js");
+const isRuntimeEnvMatch_js_1 = require("./isRuntimeEnvMatch.js");
+const serializeConfigValue_js_1 = require("../../../../../shared/page-configs/serialize/serializeConfigValue.js");
+async function getVirtualFilePageConfigValuesAll(id, userRootDir, outDirRoot, isDev, configVike) {
     const result = (0, virtualFilePageConfigValuesAll_js_1.isVirtualFileIdPageConfigValuesAll)(id);
     (0, utils_js_1.assert)(result);
     /* This assertion fails when using includeAssetsImportedByServer
@@ -24,7 +20,7 @@ async function getVirtualFilePageConfigValuesAll(id, userRootDir, isDev, configV
     }
     */
     const { pageId, isForClientSide } = result;
-    const { pageConfigs } = await (0, getVikeConfig_js_1.getVikeConfig)(userRootDir, isDev, configVike.extensions, true);
+    const { pageConfigs } = await (0, getVikeConfig_js_1.getVikeConfig)(userRootDir, outDirRoot, isDev, configVike.extensions, true);
     const pageConfig = pageConfigs.find((pageConfig) => pageConfig.pageId === pageId);
     (0, utils_js_1.assert)(pageConfig);
     const code = getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, configVike.includeAssetsImportedByServer, isDev);
@@ -38,37 +34,17 @@ function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAsse
     const lines = [];
     const importStatements = [];
     lines.push('export default [');
-    let varCounter = 0;
-    (0, getConfigValueSource_js_1.getConfigValueSourcesRelevant)(pageConfig).forEach((configValueSource) => {
-        const { valueIsImportedAtRuntime, configName, configEnv, definedAtInfo } = configValueSource;
+    const varCounterContainer = { varCounter: 0 };
+    (0, getConfigValueSourcesRelevant_js_1.getConfigValueSourcesRelevant)(pageConfig).forEach((configValueSource) => {
+        const { valueIsImportedAtRuntime, configEnv, configName } = configValueSource;
         if (!valueIsImportedAtRuntime)
             return;
         if (configValueSource.valueIsFilePath)
             return;
-        if (!(0, isConfigEnvMatch_js_1.isConfigEnvMatch)(configEnv, isForClientSide, isClientRouting))
+        if (!(0, isRuntimeEnvMatch_js_1.isRuntimeEnvMatch)(configEnv, { isForClientSide, isClientRouting, isEager: false }))
             return;
-        const { filePath, fileExportPath } = definedAtInfo;
-        (0, utils_js_1.assertPosixPath)(filePath);
-        const fileName = path_1.default.posix.basename(filePath);
-        const isPlusFile = fileName.startsWith('+');
-        const fileExportName = fileExportPath[0];
-        (0, utils_js_1.assert)(!configValueSource.valueIsFilePath);
-        (0, utils_js_1.assert)(fileExportName);
-        const { importVar, importStatement } = (0, generateEagerImport_js_1.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},`);
-            (0, utils_js_1.assert)(fileExportName);
-            lines.push(`    importFileExportName: ${JSON.stringify(fileExportName)},`);
-        }
-        lines.push(`  },`);
+        const whitespace = '  ';
+        lines.push(...(0, serializeConfigValue_js_1.serializeConfigValueImported)(configValueSource, configName, whitespace, varCounterContainer, importStatements));
     });
     lines.push('];');
     if (includeAssetsImportedByServer && isForClientSide && !isDev) {

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

@@ -5,23 +5,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getConfigValueSerialized = exports.getVirtualFilePageConfigs = void 0;
 const utils_js_1 = require("../../../utils.js");
-const generateEagerImport_js_1 = require("../generateEagerImport.js");
 const virtualFilePageConfigValuesAll_js_1 = require("../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js");
 const debug_js_1 = require("./debug.js");
 const stringify_1 = require("@brillout/json-serializer/stringify");
 const helpers_js_1 = require("./helpers.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const getVikeConfig_js_1 = require("./getVikeConfig.js");
-const isConfigEnvMatch_js_1 = require("./isConfigEnvMatch.js");
-async function getVirtualFilePageConfigs(userRootDir, isForClientSide, isDev, id, configVike, isClientRouting) {
-    const { pageConfigs, pageConfigGlobal } = await (0, getVikeConfig_js_1.getVikeConfig)(userRootDir, isDev, configVike.extensions, true);
+const isRuntimeEnvMatch_js_1 = require("./isRuntimeEnvMatch.js");
+const utils_js_2 = require("../../../../../shared/page-configs/utils.js");
+const serializeConfigValue_js_1 = require("../../../../../shared/page-configs/serialize/serializeConfigValue.js");
+async function getVirtualFilePageConfigs(userRootDir, outDirRoot, isForClientSide, isDev, id, configVike, isClientRouting) {
+    const { pageConfigs, pageConfigGlobal } = await (0, getVikeConfig_js_1.getVikeConfig)(userRootDir, outDirRoot, isDev, configVike.extensions, true);
     return getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
 }
 exports.getVirtualFilePageConfigs = getVirtualFilePageConfigs;
 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 = (0, virtualFilePageConfigValuesAll_js_1.getVirtualFileIdPageConfigValuesAll)(pageId, isForClientSide);
@@ -30,122 +32,93 @@ 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 (!(0, isRuntimeEnvMatch_js_1.isRuntimeEnvMatch)(configEnv, { isForClientSide, isClientRouting, isEager: true }))
+                return;
+            if (pageConfig.configValueSources[configName])
+                return;
+            const configValue = pageConfig.configValues[configName];
+            (0, utils_js_1.assert)(configValue);
+            const { definedAt } = configValue;
+            const valueSerialized = getConfigValueSerialized(value, configName, definedAt);
+            (0, serializeConfigValue_js_1.serializeConfigValue)(lines, configName, { definedAt, valueSerialized });
+        });
+        Object.entries(pageConfig.configValueSources).forEach(([configName]) => {
             const configValue = pageConfig.configValues[configName];
             if (configValue) {
-                const configEnv = (0, helpers_js_1.getConfigEnv)(pageConfig, configName);
+                const configEnv = (0, helpers_js_1.getConfigEnv)(pageConfig.configValueSources, configName);
                 (0, utils_js_1.assert)(configEnv, configName);
-                if (!(0, isConfigEnvMatch_js_1.isConfigEnvMatch)(configEnv, isForClientSide, isClientRouting))
+                const isEnvMatch = (0, isRuntimeEnvMatch_js_1.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];
-                (0, utils_js_1.assert)(configValueSource);
-                if (configValueSource.configEnv === '_routing-eager') {
-                    const { definedAtInfo } = configValueSource;
-                    (0, utils_js_1.assert)(!configValueSource.isComputed);
-                    const { filePath, fileExportPath } = configValueSource.definedAtInfo;
-                    const [exportName] = fileExportPath;
-                    (0, utils_js_1.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);
+                (0, serializeConfigValue_js_1.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];
+            (0, utils_js_1.assert)(configValueSource);
+            if (configValueSource.configEnv !== '_routing-eager')
+                return;
+            lines.push(...(0, serializeConfigValue_js_1.serializeConfigValueImported)(configValueSource, configName, whitespace, varCounterContainer, importStatements));
+        });
+        lines.push(`${whitespace}],`);
+        // pageConfig end
         lines.push(`  },`);
     });
     lines.push('];');
-    lines.push('export const pageConfigGlobal = {');
-    (0, utils_js_1.objectEntries)(pageConfigGlobal).forEach(([configName, configValueSource]) => {
+    lines.push('export const pageConfigGlobalSerialized = {');
+    /* Nothing (yet)
+    lines.push(`  configValuesSerialized: {`)
+    lines.push(`  },`)
+    */
+    lines.push(`  configValuesImported: [`);
+    (0, utils_js_1.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 {
             (0, utils_js_1.assert)(false);
         }
-        let whitespace = '  ';
-        let content;
-        if (configValueSource === null) {
-            content = 'null,';
-        }
-        else {
-            content = serializeConfigValueSource(configValueSource, configName, whitespace, isForClientSide, isClientRouting, importStatements, true);
-            (0, utils_js_1.assert)(content.startsWith('{') && content.endsWith('},') && content.includes('\n'));
-        }
-        content = `${whitespace}[${JSON.stringify(configName)}]: ${content}`;
-        lines.push(content);
+        const configValueSource = sources[0];
+        (0, utils_js_1.assert)(configValueSource);
+        const whitespace = '    ';
+        lines.push(...(0, serializeConfigValue_js_1.serializeConfigValueImported)(configValueSource, configName, whitespace, varCounterContainer, importStatements));
     });
+    lines.push(`  ],`);
     lines.push('};');
     const code = [...importStatements, ...lines].join('\n');
     (0, debug_js_1.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) {
-    (0, utils_js_1.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 ((0, isConfigEnvMatch_js_1.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;
-            (0, utils_js_1.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${(0, utils_js_1.getPropAccessNotation)(configName)}`;
+    let configValueSerialized;
     try {
         configValueSerialized = (0, stringify_1.stringify)(value, { valueName });
     }
     catch (err) {
         (0, utils_js_1.assert)((0, utils_js_1.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
-        (0, utils_js_1.assert)(definedAtInfo);
-        const configDefinedByFile = definedAtInfo.filePath;
-        (0, utils_js_1.assert)(configDefinedByFile);
+        const configValueFilePathToShowToUser = (0, utils_js_2.getConfigValueFilePathToShowToUser)({ definedAt });
+        (0, utils_js_1.assert)(configValueFilePathToShowToUser);
         (0, utils_js_1.assertUsage)(false, [
-            `The value of the config ${picocolors_1.default.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 ${picocolors_1.default.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(' '));
     }
@@ -153,11 +126,3 @@ function getConfigValueSerialized(value, configName, definedAtInfo) {
     return configValueSerialized;
 }
 exports.getConfigValueSerialized = getConfigValueSerialized;
-function getConfigValueEagerImport(importFilePath, exportName, importStatements) {
-    let configValueEagerImport;
-    const { importVar, importStatement } = (0, generateEagerImport_js_1.generateEagerImport)(importFilePath);
-    importStatements.push(importStatement);
-    // TODO: expose all exports so that assertDefaultExport can be applied
-    configValueEagerImport = `${importVar}[${JSON.stringify(exportName)}]`;
-    return configValueEagerImport;
-}

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

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isConfigSet = exports.getConfigEnv = void 0;
-const getConfigValueSource_js_1 = require("../../../shared/getConfigValueSource.js");
 const utils_js_1 = require("../../../utils.js");
 (0, utils_js_1.assertIsNotProductionRuntime)();
-function getConfigEnv(pageConfig, configName) {
-    const configValueSource = (0, getConfigValueSource_js_1.getConfigValueSource)(pageConfig, configName);
+function getConfigEnv(configValueSources, configName) {
+    const configValueSource = getConfigValueSource(configValueSources, configName);
     if (!configValueSource)
         return null;
     if (configValueSource) {
@@ -24,11 +23,19 @@ function getConfigEnv(pageConfig, configName) {
     }
 }
 exports.getConfigEnv = getConfigEnv;
-function isConfigSet(pageConfig, configName) {
-    const configValueSource = (0, getConfigValueSource_js_1.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;
 }
 exports.isConfigSet = isConfigSet;
+function getConfigValueSource(configValueSources, configName) {
+    const sources = configValueSources[configName];
+    if (!sources)
+        return null;
+    const configValueSource = sources[0];
+    (0, utils_js_1.assert)(configValueSource);
+    return configValueSource;
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRuntimeEnvMatch = void 0;
+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;
+}
+exports.isRuntimeEnvMatch = isRuntimeEnvMatch;

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

@@ -17,13 +17,13 @@ function replaceImportStatements(code, filePathToShowToUser) {
     imports.forEach((node) => {
         if (node.type !== 'ImportDeclaration')
             return;
-        const importFilePath = node.source.value;
-        (0, utils_js_1.assert)(typeof importFilePath === 'string');
+        const importPath = node.source.value;
+        (0, utils_js_1.assert)(typeof importPath === 'string');
         const { start, end } = node;
         const importStatementCode = code.slice(start, end);
         // No variable imported
         if (node.specifiers.length === 0) {
-            const isWarning = !utils_js_1.styleFileRE.test(importFilePath);
+            const isWarning = !utils_js_1.styleFileRE.test(importPath);
             let quote = indent(importStatementCode);
             if (isWarning) {
                 quote = picocolors_1.default.cyan(quote);
@@ -46,7 +46,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')
@@ -58,11 +58,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
             });
         });
@@ -92,35 +92,35 @@ 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);
 }
 exports.isImportData = isImportData;
-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;
         (0, utils_js_1.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 };
     }
     (0, utils_js_1.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 };
 }
 exports.parseImportData = parseImportData;
 function spliceMany(str, operations) {

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

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTmpFile = exports.getConfigExececutionErrorIntroMsg = exports.getConfigBuildErrorFormatted = exports.transpileAndExecuteFile = void 0;
+exports.isTmpFile = exports.getConfigExecutionErrorIntroMsg = exports.getConfigBuildErrorFormatted = exports.transpileAndExecuteFile = void 0;
 const esbuild_1 = require("esbuild");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -14,10 +14,11 @@ const replaceImportStatements_js_1 = require("./replaceImportStatements.js");
 const getVikeConfig_js_1 = require("./getVikeConfig.js");
 require("source-map-support/register.js");
 const getFilePathToShowToUser_js_1 = require("./getFilePathToShowToUser.js");
+const assertExports_js_1 = require("../../../../../shared/page-configs/assertExports.js");
 (0, utils_js_1.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 };
 }
 exports.transpileAndExecuteFile = transpileAndExecuteFile;
@@ -135,7 +136,7 @@ async function transpileWithEsbuild(filePath, bundle, userRootDir) {
     (0, utils_js_1.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
@@ -160,10 +161,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) {
         (0, utils_js_1.assert)(filePathRelativeToUserRootDir !== undefined);
-        const filePath = filePathRelativeToUserRootDir ?? filePathAbsolute;
-        assertFileImports(fileImports, fileExports, filePath);
+        const filePathToShowToUser = filePathRelativeToUserRootDir ?? filePathAbsolute;
+        assertImportsAreReExported(fileImports, fileExports, filePathToShowToUser);
     }
     return { fileExports };
 }
@@ -189,13 +190,13 @@ async function formatBuildErr(err, filePath) {
     err[formatted] = `${msgIntro}\n${msgEsbuild}`;
 }
 const execErrIntroMsg = new WeakMap();
-function getConfigExececutionErrorIntroMsg(err) {
+function getConfigExecutionErrorIntroMsg(err) {
     if (!(0, utils_js_1.isObject)(err))
         return null;
     const errIntroMsg = execErrIntroMsg.get(err);
     return errIntroMsg ?? null;
 }
-exports.getConfigExececutionErrorIntroMsg = getConfigExececutionErrorIntroMsg;
+exports.getConfigExecutionErrorIntroMsg = getConfigExecutionErrorIntroMsg;
 const tmpPrefix = `[build-`;
 function getFilePathTmp(filePath) {
     (0, utils_js_1.assertPosixPath)(filePath);
@@ -212,17 +213,17 @@ function isTmpFile(filePath) {
     return fileName.startsWith(tmpPrefix);
 }
 exports.isTmpFile = isTmpFile;
-function assertFileImports(fileImports, fileExports, filePath) {
-    (0, utils_js_1.assertDefaultExportObject)(fileExports, filePath);
+function assertImportsAreReExported(fileImports, fileExports, filePathToShowToUser) {
+    (0, assertExports_js_1.assertExportsOfConfigFile)(fileExports, filePathToShowToUser);
     const exportedStrings = getExportedStrings(fileExports.default);
     Object.values(exportedStrings).forEach((exportVal) => {
         if (typeof exportVal !== 'string')
             return;
         if (!(0, replaceImportStatements_js_1.isImportData)(exportVal))
             return;
-        const importDataString = exportVal;
+        const importString = exportVal;
         fileImports.forEach((fileImport) => {
-            if (fileImport.importDataString === importDataString) {
+            if (fileImport.importString === importString) {
                 fileImport.isReExported = true;
             }
         });
@@ -234,7 +235,7 @@ function assertFileImports(fileImports, fileExports, filePath) {
     const importNamesUnused = fileImportsUnused.map((fi) => picocolors_1.default.cyan(fi.importLocalName)).join(', ');
     const singular = fileImportsUnused.length === 1;
     (0, utils_js_1.assertUsage)(fileImportsUnused.length === 0, [
-        `${filePath} imports the following:`,
+        `${filePathToShowToUser} 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'));

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

@@ -9,8 +9,9 @@ const utils_js_1 = require("../utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 async function findPageFiles(config, fileTypes, isDev) {
     const cwd = config.root;
+    const { outDirRoot } = (0, utils_js_1.getOutDirs)(config);
     const timeBase = new Date().getTime();
-    let pageFiles = await (0, fast_glob_1.default)(fileTypes.map((fileType) => `**/*${fileType}.${utils_js_1.scriptFileExtensions}`), { ignore: ['**/node_modules/**'], cwd, dot: false });
+    let pageFiles = await (0, fast_glob_1.default)(fileTypes.map((fileType) => `**/*${fileType}.${utils_js_1.scriptFileExtensions}`), { ignore: ['**/node_modules/**', `${outDirRoot}/**`], cwd, dot: false });
     pageFiles = pageFiles.map((p) => '/' + (0, utils_js_1.toPosixPath)(p));
     const time = new Date().getTime() - timeBase;
     if (isDev) {

package/dist/cjs/node/plugin/shared/{getConfigValueSource.js → getConfigValueSourcesRelevant.js}

@@ -1,19 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getConfigValueSourcesRelevant = exports.getConfigValueSource = void 0;
+exports.getConfigValueSourcesRelevant = void 0;
 const utils_js_1 = require("../../shared/utils.js");
 (0, utils_js_1.assertIsNotBrowser)();
-function getConfigValueSource(pageConfig, configName) {
-    // Doesn't exist on the client-side, but we are on the server-side as attested by assertIsNotBrowser()
-    (0, utils_js_1.assert)(pageConfig.configValueSources);
-    const sources = pageConfig.configValueSources[configName];
-    if (!sources)
-        return null;
-    const configValueSource = sources[0];
-    (0, utils_js_1.assert)(configValueSource);
-    return configValueSource;
-}
-exports.getConfigValueSource = getConfigValueSource;
 function getConfigValueSourcesRelevant(pageConfig) {
     const configValueSourcesRelevant = Object.entries(pageConfig.configValueSources).map(([configName, sources]) => {
         const configValueSource = sources[0];

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

@@ -111,7 +111,7 @@ function logConfigError(err) {
     (0, utils_js_1.warnIfErrorIsNotObject)(err);
     const category = getConfigCategory();
     {
-        const errIntroMsg = (0, transpileAndExecuteFile_js_1.getConfigExececutionErrorIntroMsg)(err);
+        const errIntroMsg = (0, transpileAndExecuteFile_js_1.getConfigExecutionErrorIntroMsg)(err);
         if (errIntroMsg) {
             (0, utils_js_1.assert)((0, utils_js_1.stripAnsi)(errIntroMsg).startsWith('Failed to execute'));
             (0, log_js_1.logWithVikeTag)(errIntroMsg, 'error', category);

package/dist/cjs/node/plugin/utils.js

@@ -1,5 +1,5 @@
 "use strict";
-// Utils needed by vike's Vite plugin.
+// Utils needed by Vike's Vite plugin.
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -24,8 +24,7 @@ __exportStar(require("../runtime/utils.js"), exports);
 __exportStar(require("../../utils/viteIsSSR.js"), exports);
 __exportStar(require("../../utils/getFilePathAbsolute.js"), exports);
 __exportStar(require("../../utils/getDependencyPackageJson.js"), exports);
-__exportStar(require("../../utils/resolve.js"), exports);
-__exportStar(require("../../utils/assertDefaultExport.js"), exports);
+__exportStar(require("../../utils/requireResolve.js"), exports);
 __exportStar(require("../../utils/arrayIncludes.js"), exports);
 __exportStar(require("../../utils/isDev.js"), exports);
 __exportStar(require("../../utils/objectKeys.js"), exports);