vike 0.4.142 → 0.4.143-commit-dc6fea0

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

@@ -1,6 +1,6 @@
 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';
@@ -8,6 +8,7 @@ import { getConfigEnv } from './helpers.js';
 import pc from '@brillout/picocolors';
 import { getVikeConfig } from './getVikeConfig.js';
 import { isConfigEnvMatch } from './isConfigEnvMatch.js';
+import { serializeConfigValueImported } from './getVirtualFilePageConfigValuesAll.js';
 async function getVirtualFilePageConfigs(userRootDir, isForClientSide, isDev, id, configVike, isClientRouting) {
     const { pageConfigs, pageConfigGlobal } = await getVikeConfig(userRootDir, isDev, configVike.extensions, true);
     return getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
@@ -15,7 +16,8 @@ async function getVirtualFilePageConfigs(userRootDir, isForClientSide, isDev, id
 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);
@@ -24,7 +26,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) {
@@ -33,101 +35,71 @@ function getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, i
                 if (!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];
-                assert(configValueSource);
-                if (configValueSource.configEnv === '_routing-eager') {
-                    const { definedAtInfo } = configValueSource;
-                    const configValue = { configName, definedAtInfo };
-                    assert(!configValueSource.isComputed);
-                    const { filePath, fileExportPath } = configValueSource.definedAtInfo;
-                    const [exportName] = fileExportPath;
-                    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];
+            assert(configValueSource);
+            if (configValueSource.configEnv !== '_routing-eager')
+                return;
+            assert(!configValueSource.isComputed);
+            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, 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) {
-    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.filePath);
-            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, configDefinedByFile) {
+function getConfigValueSerialized(value, configName, definedAtInfo) {
     let configValueSerialized;
     const valueName = `config${getPropAccessNotation(configName)}`;
     try {
@@ -135,20 +107,18 @@ function getConfigValueSerialized(value, configName, configDefinedByFile) {
     }
     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);
         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 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 ${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}.)`,
+            `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.js

@@ -1,6 +1,5 @@
 export { getConfigEnv };
 export { isConfigSet };
-import { getConfigValueSource } from '../../../shared/getConfigValueSource.js';
 import { assert, assertIsNotProductionRuntime } from '../../../utils.js';
 assertIsNotProductionRuntime();
 function getConfigEnv(pageConfig, configName) {
@@ -29,3 +28,13 @@ function isConfigSet(pageConfig, configName) {
         return false;
     return !!configValueSource;
 }
+function getConfigValueSource(pageConfig, configName) {
+    // Doesn't exist on the client-side, but we are on the server-side as attested by assertIsNotBrowser()
+    assert(pageConfig.configValueSources);
+    const sources = pageConfig.configValueSources[configName];
+    if (!sources)
+        return null;
+    const configValueSource = sources[0];
+    assert(configValueSource);
+    return configValueSource;
+}

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

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

@@ -39,10 +39,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/esm/node/plugin/shared/{getConfigValueSource.d.ts → getConfigValueSourcesRelevant.d.ts}

@@ -1,7 +1,5 @@
-export { getConfigValueSource };
 export { getConfigValueSourcesRelevant };
 import type { ConfigValueSource, PageConfigBuildTime } from '../../../shared/page-configs/PageConfig.js';
-declare function getConfigValueSource(pageConfig: PageConfigBuildTime, configName: string): null | ConfigValueSource;
 declare function getConfigValueSourcesRelevant(pageConfig: PageConfigBuildTime): (ConfigValueSource & {
     configName: string;
 })[];

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

@@ -1,17 +1,6 @@
-export { getConfigValueSource };
 export { getConfigValueSourcesRelevant };
 import { assert, assertIsNotBrowser } from '../../shared/utils.js';
 assertIsNotBrowser();
-function getConfigValueSource(pageConfig, configName) {
-    // Doesn't exist on the client-side, but we are on the server-side as attested by assertIsNotBrowser()
-    assert(pageConfig.configValueSources);
-    const sources = pageConfig.configValueSources[configName];
-    if (!sources)
-        return null;
-    const configValueSource = sources[0];
-    assert(configValueSource);
-    return configValueSource;
-}
 function getConfigValueSourcesRelevant(pageConfig) {
     const configValueSourcesRelevant = Object.entries(pageConfig.configValueSources).map(([configName, sources]) => {
         const configValueSource = sources[0];

package/dist/esm/node/plugin/shared/loggerNotProd/errorWithCodeSnippet.js

@@ -7,7 +7,7 @@ export { isEquivalentErrorWithCodeSnippet };
 export { getPrettyErrMessage };
 // Copied & adapted from https://github.com/vitejs/vite/blob/9c114c5c72a6af87e3330d5573362554b4511265/packages/vite/src/node/server/middlewares/error.ts
 import pc from '@brillout/picocolors';
-import { assert, escapeRegex, getFilePathVite, isObject, removeEmptyLines, stripAnsi, toPosixPath } from '../../utils.js';
+import { assert, escapeRegex, getFilePathRelativeToUserRootDir, isObject, removeEmptyLines, stripAnsi, toPosixPath } from '../../utils.js';
 function isErrorWithCodeSnippet(err) {
     if (!isObject(err)) {
         return false;
@@ -46,7 +46,7 @@ function getPrettyErrorWithCodeSnippet(err, userRootDir) {
     let { id, frame } = err;
     const msgFirstLine = [
         pc.red('Failed to transpile'),
-        pc.bold(pc.red(getFilePathVite(normalizeId(id), userRootDir))),
+        pc.bold(pc.red(getFilePathRelativeToUserRootDir(normalizeId(id), userRootDir))),
         pc.red('because:')
     ].join(' ');
     const errMsg = getPrettyErrMessage(err);

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

@@ -18,7 +18,7 @@ import { assert, assertIsNotProductionRuntime, getAssertErrMsg, isUserHookError,
 import { getHttpRequestAsyncStore } from './getHttpRequestAsyncStore.js';
 import { isErrorDebug } from './isErrorDebug.js';
 import { isErrorWithCodeSnippet, getPrettyErrorWithCodeSnippet } from './loggerNotProd/errorWithCodeSnippet.js';
-import { getConfigExececutionErrorIntroMsg, getConfigBuildErrorFormatted } from '../plugins/importUserCode/v1-design/transpileAndExecuteFile.js';
+import { getConfigExecutionErrorIntroMsg, getConfigBuildErrorFormatted } from '../plugins/importUserCode/v1-design/transpileAndExecuteFile.js';
 import { logWithVikeTag, logWithViteTag, logDirectly, isFirstLog, screenHasErrors, clearScreen } from './loggerNotProd/log.js';
 import pc from '@brillout/picocolors';
 import { setAlreadyLogged } from '../../runtime/renderPage/isNewError.js';
@@ -108,7 +108,7 @@ function logConfigError(err) {
     warnIfErrorIsNotObject(err);
     const category = getConfigCategory();
     {
-        const errIntroMsg = getConfigExececutionErrorIntroMsg(err);
+        const errIntroMsg = getConfigExecutionErrorIntroMsg(err);
         if (errIntroMsg) {
             assert(stripAnsi(errIntroMsg).startsWith('Failed to execute'));
             logWithVikeTag(errIntroMsg, 'error', category);
@@ -194,9 +194,9 @@ function logErrorDebugNote() {
         store.errorDebugNoteAlreadyShown = true;
     }
     const msg = pc.dim([
-        '┌─────────────────────────────────────────────────────────────────────┐',
+        '┌──────────────────────────────────────────────────────────┐',
         "│ Error isn't helpful? See https://vike.dev/errors#verbose │",
-        '└─────────────────────────────────────────────────────────────────────┘'
+        '└──────────────────────────────────────────────────────────┘'
     ].join('\n'));
     logDirectly(msg, 'error');
 }

package/dist/esm/node/plugin/utils.d.ts

@@ -2,8 +2,7 @@ export * from '../runtime/utils.js';
 export * from '../../utils/viteIsSSR.js';
 export * from '../../utils/getFilePathAbsolute.js';
 export * from '../../utils/getDependencyPackageJson.js';
-export * from '../../utils/addFileExtensionsToRequireResolve.js';
-export * from '../../utils/assertDefaultExport.js';
+export * from '../../utils/requireResolve.js';
 export * from '../../utils/arrayIncludes.js';
 export * from '../../utils/isDev.js';
 export * from '../../utils/objectKeys.js';

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

@@ -8,8 +8,7 @@ export * from '../runtime/utils.js';
 export * from '../../utils/viteIsSSR.js';
 export * from '../../utils/getFilePathAbsolute.js';
 export * from '../../utils/getDependencyPackageJson.js';
-export * from '../../utils/addFileExtensionsToRequireResolve.js';
-export * from '../../utils/assertDefaultExport.js';
+export * from '../../utils/requireResolve.js';
 export * from '../../utils/arrayIncludes.js';
 export * from '../../utils/isDev.js';
 export * from '../../utils/objectKeys.js';