vike 0.4.142 → 0.4.143-commit-dc6fea0

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

@@ -3,9 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVirtualFilePageConfigs = void 0;
+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");
@@ -13,6 +12,7 @@ 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");
+const getVirtualFilePageConfigValuesAll_js_1 = require("./getVirtualFilePageConfigValuesAll.js");
 async function getVirtualFilePageConfigs(userRootDir, isForClientSide, isDev, id, configVike, isClientRouting) {
     const { pageConfigs, pageConfigGlobal } = await (0, getVikeConfig_js_1.getVikeConfig)(userRootDir, isDev, configVike.extensions, true);
     return getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
@@ -21,7 +21,8 @@ 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,7 +31,7 @@ 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: {`);
+        lines.push(`    configValuesSerialized: {`);
         Object.entries(pageConfig.configValueSources).forEach(([configName, sources]) => {
             const configValue = pageConfig.configValues[configName];
             if (configValue) {
@@ -39,101 +40,71 @@ function getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, i
                 if (!(0, isConfigEnvMatch_js_1.isConfigEnvMatch)(configEnv, isForClientSide, isClientRouting))
                     return;
                 const { value, definedAtInfo } = configValue;
-                // TODO: use @brillout/json-serializer
-                //  - re-use getConfigValueSerialized()?
-                const valueSerialized = JSON.stringify(value);
-                serializeConfigValue(lines, configName, { definedAtInfo }, valueSerialized);
-            }
-            else {
-                const configValueSource = sources[0];
-                (0, utils_js_1.assert)(configValueSource);
-                if (configValueSource.configEnv === '_routing-eager') {
-                    const { definedAtInfo } = configValueSource;
-                    const configValue = { configName, definedAtInfo };
-                    (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);
-                    serializeConfigValue(lines, configName, configValue, configValueEagerImport);
-                }
+                const valueSerialized = getConfigValueSerialized(value, configName, definedAtInfo);
+                serializeConfigValue(lines, configName, { definedAtInfo, 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;
+            (0, utils_js_1.assert)(!configValueSource.isComputed);
+            lines.push(...(0, getVirtualFilePageConfigValuesAll_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, getVirtualFilePageConfigValuesAll_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, valueSerialized) {
+function serializeConfigValue(lines, configName, configValueSerialized) {
     let whitespace = '      ';
     lines.push(`${whitespace}['${configName}']: {`);
     whitespace += '  ';
-    lines.push(`${whitespace}  value: ${valueSerialized},`);
-    Object.entries(configValue).forEach(([key, val]) => {
-        if (key === 'value')
-            return;
-        // if (val === undefined) return
-        lines.push(`${whitespace}  ${key}: ${JSON.stringify(val)},`);
+    Object.entries(configValueSerialized).forEach(([key, val]) => {
+        const valSerialized = key === 'definedAtInfo' ? JSON.stringify(val) : 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.filePath);
-            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, configDefinedByFile) {
+function getConfigValueSerialized(value, configName, definedAtInfo) {
     let configValueSerialized;
     const valueName = `config${(0, utils_js_1.getPropAccessNotation)(configName)}`;
     try {
@@ -141,20 +112,19 @@ function getConfigValueSerialized(value, configName, configDefinedByFile) {
     }
     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);
         (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 it isn't serializable: ${err.messageCore}).`,
-            `Only serializable config values can be defined inside ${configDefinedByFile}, see https://vike.dev/header-file.`
+            `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}.)`,
+            `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 } = (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;
-}
+exports.getConfigValueSerialized = getConfigValueSerialized;

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);
+    const configValueSource = getConfigValueSource(pageConfig, configName);
     if (!configValueSource)
         return null;
     if (configValueSource) {
@@ -25,10 +24,20 @@ function getConfigEnv(pageConfig, configName) {
 }
 exports.getConfigEnv = getConfigEnv;
 function isConfigSet(pageConfig, configName) {
-    const configValueSource = (0, getConfigValueSource_js_1.getConfigValueSource)(pageConfig, configName);
+    const configValueSource = getConfigValueSource(pageConfig, 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(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;
+}

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;
@@ -55,7 +56,9 @@ function transpileImports(codeOriginal, filePath, isValueFile) {
     const { code, fileImports } = res;
     if (!isHeader) {
         const filePathCorrect = appendHeaderFileExtension(filePathToShowToUser);
-        (0, utils_js_1.assertWarning)(false, `Rename ${filePathToShowToUser} to ${filePathCorrect}, see https://vike.dev/header-file`, { onlyOnce: true });
+        (0, utils_js_1.assertWarning)(false, `Rename ${filePathToShowToUser} to ${filePathCorrect}, see https://vike.dev/header-file`, {
+            onlyOnce: true
+        });
     }
     return { code, fileImports };
 }
@@ -133,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
@@ -158,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 };
 }
@@ -187,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);
@@ -210,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;
             }
         });
@@ -231,11 +234,11 @@ function assertFileImports(fileImports, fileExports, filePath) {
     const importStatements = (0, utils_js_1.unique)(fileImportsUnused.map((fi) => fi.importStatementCode));
     const importNamesUnused = fileImportsUnused.map((fi) => picocolors_1.default.cyan(fi.importLocalName)).join(', ');
     const singular = fileImportsUnused.length === 1;
-    (0, utils_js_1.assertWarning)(fileImportsUnused.length === 0, [
-        `${filePath} imports the following:`,
+    (0, utils_js_1.assertUsage)(fileImportsUnused.length === 0, [
+        `${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'), { onlyOnce: true });
+    ].join('\n'));
 }
 function getExportedStrings(obj) {
     const exportedStrings = [];

package/dist/cjs/node/plugin/plugins/suppressRollupWarning.js

@@ -42,10 +42,23 @@ function suppressUnusedImport(warning) {
     if (warning.code !== 'UNUSED_EXTERNAL_IMPORT')
         return false;
     // I guess it's expected that JSX contains unsused `import React from 'react'`
-    if (warning.exporter === 'react' && warning.names?.includes('default'))
-        return true;
+    if (warning.exporter === 'react' && warning.names?.includes('default')) {
+        warning.names = warning.names.filter((n) => n !== 'default');
+        if (warning.names.length === 0)
+            return true;
+    }
+    // Suppress:
+    // ```
+    // "untrack" is imported from external module "solid-js" but never used in "pages/star-wars/index/+Page.tsx", "pages/index/Counter.tsx", "components/Link.tsx", "pages/todo/TodoList.tsx" and "pages/todo/+Page.tsx".
+    // ```
+    // I'm guessing Solid's transformer injects `import { untrack } from 'solid-js'`
+    if (warning.exporter === 'solid-js' && warning.names?.includes('untrack')) {
+        warning.names = warning.names.filter((n) => n !== 'untrack');
+        if (warning.names.length === 0)
+            return true;
+    }
     // If some library does something unexpected, we suppress since it isn't actionable
-    if (warning.ids?.some((id) => id.includes('/node_modules/')))
+    if (warning.ids?.every((id) => id.includes('/node_modules/')))
         return true;
     return false;
 }

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/errorWithCodeSnippet.js

@@ -48,7 +48,7 @@ function getPrettyErrorWithCodeSnippet(err, userRootDir) {
     let { id, frame } = err;
     const msgFirstLine = [
         picocolors_1.default.red('Failed to transpile'),
-        picocolors_1.default.bold(picocolors_1.default.red((0, utils_js_1.getFilePathVite)(normalizeId(id), userRootDir))),
+        picocolors_1.default.bold(picocolors_1.default.red((0, utils_js_1.getFilePathRelativeToUserRootDir)(normalizeId(id), userRootDir))),
         picocolors_1.default.red('because:')
     ].join(' ');
     const errMsg = getPrettyErrMessage(err);

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);
@@ -199,9 +199,9 @@ function logErrorDebugNote() {
         store.errorDebugNoteAlreadyShown = true;
     }
     const msg = picocolors_1.default.dim([
-        '┌─────────────────────────────────────────────────────────────────────┐',
+        '┌──────────────────────────────────────────────────────────┐',
         "│ Error isn't helpful? See https://vike.dev/errors#verbose │",
-        '└─────────────────────────────────────────────────────────────────────┘'
+        '└──────────────────────────────────────────────────────────┘'
     ].join('\n'));
     (0, log_js_1.logDirectly)(msg, 'error');
 }

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

@@ -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/addFileExtensionsToRequireResolve.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);

package/dist/cjs/node/prerender/runPrerender.js

@@ -42,7 +42,7 @@ const getPageFiles_js_1 = require("../../shared/getPageFiles.js");
 const getPageContextRequestUrl_js_1 = require("../../shared/getPageContextRequestUrl.js");
 const resolveRouteString_js_1 = require("../../shared/route/resolveRouteString.js");
 const utils_js_2 = require("../../shared/page-configs/utils.js");
-const loadPageCode_js_1 = require("../../shared/page-configs/loadPageCode.js");
+const loadConfigValues_js_1 = require("../../shared/page-configs/loadConfigValues.js");
 const error_page_js_1 = require("../../shared/error-page.js");
 const addUrlComputedProps_js_1 = require("../../shared/addUrlComputedProps.js");
 const assertPathIsFilesystemAbsolute_js_1 = require("../../utils/assertPathIsFilesystemAbsolute.js");
@@ -171,7 +171,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
     // V1 design
     await Promise.all(renderContext.pageConfigs.map((pageConfig) => concurrencyLimit(async () => {
         const hookName = 'onBeforePrerenderStart';
-        const pageConfigLoaded = await (0, loadPageCode_js_1.loadPageCode)(pageConfig, false);
+        const pageConfigLoaded = await (0, loadConfigValues_js_1.loadConfigValues)(pageConfig, false);
         const configValue = (0, utils_js_2.getConfigValue)(pageConfigLoaded, hookName);
         if (!configValue)
             return;
@@ -309,20 +309,17 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
     let onPrerenderStartHook;
     // V1 design
     if (renderContext.pageConfigs.length > 0) {
-        const configValueSource = renderContext.pageConfigGlobal.onPrerenderStart;
-        if (configValueSource) {
-            const hookFn = configValueSource.value;
-            (0, utils_js_1.assert)(!configValueSource.isComputed);
-            const hookFilePath = configValueSource.definedAtInfo.filePath;
-            (0, utils_js_1.assert)(hookFn);
-            (0, utils_js_1.assert)(hookFilePath);
-            if (hookFn) {
-                onPrerenderStartHook = {
-                    hookFn,
-                    hookName: 'onPrerenderStart',
-                    hookFilePath
-                };
-            }
+        const { pageConfigGlobal } = renderContext;
+        if (pageConfigGlobal.configValues.onPrerenderStart?.value) {
+            const { value: hookFn, definedAtInfo } = pageConfigGlobal.configValues.onPrerenderStart;
+            // config.onPrerenderStart isn't a computed nor a cumulative config => definedAtInfo should always be defined
+            (0, utils_js_1.assert)(definedAtInfo);
+            const hookFilePath = definedAtInfo.filePath;
+            onPrerenderStartHook = {
+                hookFn,
+                hookName: 'onPrerenderStart',
+                hookFilePath
+            };
         }
     }
     // Old design

package/dist/cjs/node/runtime/html/injectAssets/getHtmlTags.js

@@ -111,7 +111,7 @@ async function getHtmlTags(pageContext, injectToStream, injectFilter) {
     if (!isHtmlOnly) {
         // Don't allow the user to manipulate with injectFilter(): injecting <script type="application/json"> before the stream can break the app when:
         //  - using https://vike.dev/stream#initial-data-after-stream-end
-        //  - `pageContext` is modified during the stream, e.g. /examples/vue-pinia which uses https://vuejs.org/api/composition-api-lifecycle.html#onserverprefetch
+        //  - `pageContext` is modified during the stream, e.g. https://github.com/brillout/vike-with-pinia which uses https://vuejs.org/api/composition-api-lifecycle.html#onserverprefetch
         // The <script> tags are handled separately by vike down below.
         htmlTags.push({
             // Needs to be called after `resolvePageContextPromise()`

package/dist/cjs/node/runtime/html/stream.js

@@ -627,7 +627,10 @@ exports.isStreamPipeWeb = isStreamPipeWeb;
 const __streamPipeNode = '__streamPipeNode';
 /** @deprecated */
 function pipeNodeStream(pipe) {
-    (0, utils_js_1.assertWarning)(false, 'pipeNodeStream() is outdated, use stampPipe() instead. See https://vike.dev/stream', { onlyOnce: true, showStackTrace: true });
+    (0, utils_js_1.assertWarning)(false, 'pipeNodeStream() is outdated, use stampPipe() instead. See https://vike.dev/stream', {
+        onlyOnce: true,
+        showStackTrace: true
+    });
     return { [__streamPipeNode]: pipe };
 }
 exports.pipeNodeStream = pipeNodeStream;

package/dist/cjs/node/runtime/renderPage/analyzePage.js

@@ -28,14 +28,14 @@ function analyzePage(pageFilesAll, pageConfig, pageId) {
         }
         /* Remove?
         Object.values(pageConfig.configElements).forEach((configElement) => {
-          if (configElement.importFilePath) {
+          if (configElement.importPath) {
             const { env } = configElement
             assert(env)
             const onlyAssets = env === 'server-only'
             const eagerlyImported = env === '_routing-eager'
             if (onlyAssets || eagerlyImported) {
               clientDependencies.push({
-                id: configElement.importFilePath,
+                id: configElement.importPath,
                 onlyAssets,
                 eagerlyImported
               })