vike 0.4.143-commit-fa295e1 → 0.4.144-commit-e40e9b1

package/dist/esm/shared/page-configs/{parseConfigValuesImported.js → serialize/parseConfigValuesImported.js}

@@ -1,6 +1,6 @@
 export { parseConfigValuesImported };
-import { assert, assertUsage } from '../utils.js';
-import { assertExportsOfValueFile } from './assertExports.js';
+import { assert, assertUsage } from '../../utils.js';
+import { assertExportsOfValueFile } from '../assertExports.js';
 import pc from '@brillout/picocolors';
 function parseConfigValuesImported(configValuesImported) {
     const configValues = {};
@@ -8,10 +8,13 @@ function parseConfigValuesImported(configValuesImported) {
         configValues[configName] = {
             value,
             definedAt: {
-                source: {
-                    // importPath is always relative the user's root directory (it cannot be relative to the current file since the current file is a virtual file)
+                file: {
+                    // importPath cannot be relative to the current file, since the current file is a virtual file
                     filePathToShowToUser: importPath,
-                    fileExportPath: [exportName]
+                    fileExportPath: [configName, 'default'].includes(exportName)
+                        ? []
+                        : // Side-effect config
+                            [exportName]
                 }
             }
         };
@@ -19,11 +22,11 @@ function parseConfigValuesImported(configValuesImported) {
     };
     configValuesImported.forEach((configValueLoaded) => {
         if (configValueLoaded.isValueFile) {
-            const { importFileExports, importPath, configName } = configValueLoaded;
+            const { exportValues, importPath, configName } = configValueLoaded;
             if (configName !== 'client') {
-                assertExportsOfValueFile(importFileExports, importPath, configName);
+                assertExportsOfValueFile(exportValues, importPath, configName);
             }
-            Object.entries(importFileExports).forEach(([exportName, exportValue]) => {
+            Object.entries(exportValues).forEach(([exportName, exportValue]) => {
                 const isSideExport = exportName !== 'default'; // .md files may have "side-exports" such as `export { frontmatter }`
                 const configName = isSideExport ? exportName : configValueLoaded.configName;
                 if (isSideExport && configName in configValues) {
@@ -35,8 +38,8 @@ function parseConfigValuesImported(configValuesImported) {
             });
         }
         else {
-            const { configName, importPath, importFileExportValue, exportName } = configValueLoaded;
-            addConfigValue(configName, importFileExportValue, importPath, exportName);
+            const { configName, importPath, exportValue, exportName } = configValueLoaded;
+            addConfigValue(configName, exportValue, importPath, exportName);
         }
     });
     return configValues;

package/dist/esm/shared/page-configs/serialize/parsePageConfigs.d.ts

@@ -0,0 +1,7 @@
+export { parsePageConfigs };
+import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../PageConfig.js';
+import type { PageConfigGlobalRuntimeSerialized, PageConfigRuntimeSerialized } from './PageConfigSerialized.js';
+declare function parsePageConfigs(pageConfigsSerialized: PageConfigRuntimeSerialized[], pageConfigGlobalSerialized: PageConfigGlobalRuntimeSerialized): {
+    pageConfigs: PageConfigRuntime[];
+    pageConfigGlobal: PageConfigGlobalRuntime;
+};

package/dist/esm/shared/{getPageFiles/parsePageConfigsSerialized.js → page-configs/serialize/parsePageConfigs.js}

@@ -1,9 +1,9 @@
-export { parsePageConfigsSerialized };
+export { parsePageConfigs };
 import { parse } from '@brillout/json-serializer/parse';
-import { parseConfigValuesImported } from '../page-configs/parseConfigValuesImported.js';
-import { assert, assertUsage, isCallable } from '../utils.js';
-import { getConfigDefinedAtString } from '../page-configs/utils.js';
-function parsePageConfigsSerialized(pageConfigsSerialized, pageConfigGlobalSerialized) {
+import { parseConfigValuesImported } from './parseConfigValuesImported.js';
+import { assert, assertUsage, isCallable } from '../../utils.js';
+import { getConfigDefinedAtString } from '../utils.js';
+function parsePageConfigs(pageConfigsSerialized, pageConfigGlobalSerialized) {
     const pageConfigs = pageConfigsSerialized.map((pageConfigSerialized) => {
         const configValues = {};
         {

package/dist/esm/shared/page-configs/serialize/serializeConfigValue.d.ts

@@ -0,0 +1,8 @@
+export { serializeConfigValue };
+export { serializeConfigValueImported };
+import { ConfigValueSource } from '../PageConfig.js';
+import { ConfigValueSerialized } from './PageConfigSerialized.js';
+declare function serializeConfigValue(lines: string[], configName: string, configValueSerialized: ConfigValueSerialized): void;
+declare function serializeConfigValueImported(configValueSource: ConfigValueSource, configName: string, whitespace: string, varCounterContainer: {
+    varCounter: number;
+}, importStatements: string[]): string[];

package/dist/esm/shared/page-configs/serialize/serializeConfigValue.js

@@ -0,0 +1,52 @@
+export { serializeConfigValue };
+export { serializeConfigValueImported };
+// This file is never loaded on the client-side but we save it under the vike/shared/ directory in order to collocate it with:
+//   - vike/shared/page-configs/serialize/parsePageConfigs.ts
+//   - vike/shared/page-configs/serialize/parseConfigValuesImported.ts
+// Both parsePageConfigs() parseConfigValuesImported() and are loaded on the client-side and server-side
+import { assertIsNotProductionRuntime } from '../../../utils/assertIsNotProductionRuntime.js';
+assertIsNotProductionRuntime();
+import path from 'path';
+import { assert, assertPosixPath } from '../../utils.js';
+import { generateEagerImport } from '../../../node/plugin/plugins/importUserCode/generateEagerImport.js';
+function serializeConfigValue(lines, configName, configValueSerialized) {
+    let whitespace = '      ';
+    lines.push(`${whitespace}['${configName}']: {`);
+    whitespace += '  ';
+    Object.entries(configValueSerialized).forEach(([key, val]) => {
+        const valSerialized = key === 'definedAt' ? JSON.stringify(val) : val;
+        lines.push(`${whitespace}  ${key}: ${valSerialized},`);
+    });
+    whitespace = whitespace.slice(2);
+    lines.push(`${whitespace}},`);
+}
+function serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements) {
+    assert(!configValueSource.valueIsFilePath);
+    assert(whitespace.replaceAll(' ', '').length === 0);
+    const { valueIsImportedAtRuntime, definedAtInfo } = configValueSource;
+    assert(valueIsImportedAtRuntime);
+    const { filePathRelativeToUserRootDir, importPathAbsolute, exportName } = definedAtInfo;
+    const importPath = filePathRelativeToUserRootDir ?? importPathAbsolute;
+    assertPosixPath(importPath);
+    const fileName = path.posix.basename(importPath);
+    const isValueFile = fileName.startsWith('+');
+    if (isValueFile)
+        assert(exportName === undefined);
+    const { importName, importStatement } = generateEagerImport(importPath, varCounterContainer.varCounter++, exportName);
+    importStatements.push(importStatement);
+    const lines = [];
+    lines.push(`  {`);
+    lines.push(`    configName: '${configName}',`);
+    lines.push(`    importPath: '${importPath}',`);
+    lines.push(`    isValueFile: ${JSON.stringify(isValueFile)},`);
+    if (isValueFile) {
+        lines.push(`    exportValues: ${importName},`);
+    }
+    else {
+        lines.push(`    exportValue: ${importName},`);
+        assert(exportName);
+        lines.push(`    exportName: ${JSON.stringify(exportName)},`);
+    }
+    lines.push(`  },`);
+    return lines;
+}

package/dist/esm/shared/page-configs/utils.d.ts

@@ -18,15 +18,15 @@ declare function getConfigValue(pageConfig: PageConfigCommon, configName: Config
     value: unknown;
 };
 declare function getPageConfig(pageId: string, pageConfigs: PageConfigRuntime[]): PageConfigRuntime;
-type ConfigDefinedAtUppercase<ConfigName extends string> = `Config ${ConfigName} defined ${string}`;
-type ConfigDefinedAtLowercase<ConfigName extends string> = `config ${ConfigName} defined ${string}`;
+type ConfigDefinedAtUppercase<ConfigName extends string> = `Config ${ConfigName} defined ${'internally' | `at ${string}`}`;
+type ConfigDefinedAtLowercase<ConfigName extends string> = `config ${ConfigName} defined ${'internally' | `at ${string}`}`;
 declare function getConfigDefinedAtString<ConfigName extends string>(configName: ConfigName, { definedAt }: {
     definedAt: DefinedAt;
 }, sentenceBegin: true, append?: 'effect'): ConfigDefinedAtUppercase<ConfigName>;
 declare function getConfigDefinedAtString<ConfigName extends string>(configName: ConfigName, { definedAt }: {
     definedAt: DefinedAt;
 }, sentenceBegin: false, append?: 'effect'): ConfigDefinedAtLowercase<ConfigName>;
-declare function getDefinedAtString(configValue: ConfigValue): string;
+declare function getDefinedAtString(configValue: ConfigValue, configName: string): string;
 declare function getConfigValueFilePathToShowToUser({ definedAt }: {
     definedAt: DefinedAt;
 }): null | string;

package/dist/esm/shared/page-configs/utils.js

@@ -43,26 +43,26 @@ function getPageConfig(pageId, pageConfigs) {
     return pageConfig;
 }
 function getConfigDefinedAtString(configName, { definedAt }, sentenceBegin) {
-    const configDefinedAt = `${sentenceBegin ? `Config` : `config`} ${pc.cyan(configName)} defined ${getSourceString(definedAt)}`;
+    const configDefinedAt = `${sentenceBegin ? `Config` : `config`} ${pc.cyan(configName)} defined ${getSourceString(definedAt, configName)}`;
     return configDefinedAt;
 }
-function getSourceString(definedAt) {
+function getSourceString(definedAt, configName) {
     if (definedAt.isComputed) {
         return 'internally';
     }
-    let sources;
+    let files;
     if (definedAt.isCumulative) {
-        sources = definedAt.sources;
+        files = definedAt.files;
     }
     else {
-        sources = [definedAt.source];
+        files = [definedAt.file];
     }
-    assert(sources.length >= 1);
-    const sourceString = sources
+    assert(files.length >= 1);
+    const sourceString = files
         .map((source) => {
         const { filePathToShowToUser, fileExportPath } = source;
         let s = filePathToShowToUser;
-        const exportPath = getExportPath(fileExportPath);
+        const exportPath = getExportPath(fileExportPath, configName);
         if (exportPath) {
             s = `${s} > ${pc.cyan(exportPath)}`;
         }
@@ -74,8 +74,8 @@ function getSourceString(definedAt) {
         .join(' / ');
     return `at ${sourceString}`;
 }
-function getDefinedAtString(configValue) {
-    let sourceString = getSourceString(configValue.definedAt);
+function getDefinedAtString(configValue, configName) {
+    let sourceString = getSourceString(configValue.definedAt, configName);
     if (sourceString.startsWith('at '))
         sourceString = sourceString.slice('at '.length);
     return sourceString;
@@ -86,8 +86,7 @@ function getConfigValueFilePathToShowToUser({ definedAt }) {
     //  - computed values don't have any file path
     if (definedAt.isComputed || definedAt.isCumulative)
         return null;
-    const { source } = definedAt;
-    const { filePathToShowToUser } = source;
+    const { filePathToShowToUser } = definedAt.file;
     assert(filePathToShowToUser);
     return filePathToShowToUser;
 }

package/dist/esm/shared/route/loadPageRoutes.js

@@ -31,7 +31,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                 const configValue = getConfigValue(pageConfig, configName);
                 if (configValue) {
                     const route = configValue.value;
-                    const definedAt = getDefinedAtString(configValue);
+                    const definedAt = getDefinedAtString(configValue, configName);
                     if (typeof route === 'string') {
                         pageRoute = {
                             pageId,

package/dist/esm/utils/getOutDirs.d.ts

@@ -1,5 +1,4 @@
 export { getOutDirs };
-export { getOutDirs_prerender };
 export { resolveOutDir };
 import type { UserConfig, ResolvedConfig } from 'vite';
 type OutDirs = {
@@ -11,6 +10,5 @@ type OutDirs = {
     outDirServer: string;
 };
 declare function getOutDirs(config: ResolvedConfig): OutDirs;
-declare function getOutDirs_prerender(config: ResolvedConfig): OutDirs;
 /** Appends `client/` or `server/` to `config.build.outDir` */
 declare function resolveOutDir(config: UserConfig): string;

package/dist/esm/utils/getOutDirs.js

@@ -1,5 +1,4 @@
 export { getOutDirs };
-export { getOutDirs_prerender };
 export { resolveOutDir };
 import { viteIsSSR } from './viteIsSSR.js';
 import { assert, assertUsage } from './assert.js';
@@ -7,21 +6,24 @@ import { pathJoin } from './path-shim.js';
 import { assertPosixPath, toPosixPath } from './filesystemPathHandling.js';
 import pc from '@brillout/picocolors';
 function getOutDirs(config) {
-    const outDir = getOutDirFromResolvedConfig(config);
-    assertOutDirResolved(outDir, config);
-    assert(outDir.endsWith('/server') || outDir.endsWith('/client'));
-    assert('/client'.length === '/server'.length);
-    const outDirRoot = outDir.slice(0, -1 * '/client'.length);
-    return getOutDirsAll(outDirRoot, config.root);
-}
-function getOutDirs_prerender(config) {
-    const outDirRoot = getOutDirFromResolvedConfig(config);
-    assert(isOutDirRoot(outDirRoot));
+    let outDirRoot;
+    {
+        const outDir = getOutDirFromViteResolvedConfig(config);
+        if (isOutDirRoot(outDir)) {
+            outDirRoot = outDir;
+        }
+        else {
+            assertOutDirResolved(outDir, config);
+            assert(outDir.endsWith('/server') || outDir.endsWith('/client'));
+            assert('/client'.length === '/server'.length);
+            outDirRoot = outDir.slice(0, -1 * '/client'.length);
+        }
+    }
     return getOutDirsAll(outDirRoot, config.root);
 }
 /** Appends `client/` or `server/` to `config.build.outDir` */
 function resolveOutDir(config) {
-    const outDir = getOutDirFromUserConfig(config) || 'dist';
+    const outDir = getOutDirFromViteUserConfig(config) || 'dist';
     // outDir may already be resolved when using Telefunc + vike (because both Telefunc and vike use this logic)
     if (!isOutDirRoot(outDir)) {
         assertOutDirResolved(outDir, config);
@@ -39,6 +41,7 @@ function resolveOutDir(config) {
 }
 function determineOutDirs(outDirRoot) {
     assertPosixPath(outDirRoot);
+    assert(!outDirRoot.endsWith('/'));
     assert(isOutDirRoot(outDirRoot));
     const outDirClient = pathJoin(outDirRoot, 'client');
     const outDirServer = pathJoin(outDirRoot, 'server');
@@ -89,18 +92,22 @@ function assertOutDirResolved(outDir, config) {
         assertUsage(outDir.endsWith('/client'), wrongUsage);
     }
 }
-function getOutDirFromUserConfig(config) {
+function getOutDirFromViteUserConfig(config) {
     let outDir = config.build?.outDir;
     if (outDir === undefined)
         return undefined;
-    // I believe Vite normalizes config.build.outDir only if config is ResolvedConfig
-    outDir = toPosixPath(outDir);
+    outDir = normalize(outDir);
     return outDir;
 }
-function getOutDirFromResolvedConfig(config) {
+function getOutDirFromViteResolvedConfig(config) {
     let outDir = config.build.outDir;
-    // Vite seems to be buggy and doesn't always normalize config.build.outDir
+    assert(outDir);
+    outDir = normalize(outDir);
+    return outDir;
+}
+function normalize(outDir) {
     outDir = toPosixPath(outDir);
+    outDir = outDir.replace(/\/+$/, ''); // remove trailing slashes
     return outDir;
 }
 function outDirIsAbsolutePath(outDir) {

package/dist/esm/utils/getValuePrintable.js

@@ -1,7 +1,7 @@
 export function getValuePrintable(value) {
     if ([null, undefined].includes(value))
         return String(value);
-    if (['undefined', 'boolean', 'number', 'string'].includes(typeof value))
+    if (['boolean', 'number', 'string'].includes(typeof value))
         return JSON.stringify(value);
     return null;
 }

package/dist/esm/utils/projectInfo.d.ts

@@ -5,7 +5,7 @@ type ProjectVersion = typeof projectInfo.projectVersion;
 type ProjectTag = `[${PackageName}]` | `[${PackageName}@${ProjectVersion}]`;
 declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.143-commit-fa295e1";
+    projectVersion: "0.4.144-commit-e40e9b1";
     npmPackageName: "vike";
     githubRepository: "https://github.com/vikejs/vike";
 };

package/dist/esm/utils/projectInfo.js

@@ -1,6 +1,6 @@
 export { projectInfo };
 import { onProjectInfo } from './assertSingleInstance.js';
-const PROJECT_VERSION = '0.4.143-commit-fa295e1';
+const PROJECT_VERSION = '0.4.144-commit-e40e9b1';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION,

package/dist/esm/utils/warnIfErrorIsNotObject.js

@@ -7,7 +7,7 @@ assertIsNotBrowser();
 // It would be cleaner to:
 //  - Call assertUsageErrorIsObject() right after calling the user's hook
 //    - Attach the original error: assertUsageError.originalErrorValue = err
-//      - Show the original error in vike's error handling
+//      - Show the original error in Vike's error handling
 //  - Use assertErrorIsObject() throughout Vike's source code
 function warnIfErrorIsNotObject(err) {
     if (!isObject(err)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.143-commit-fa295e1",
+  "version": "0.4.144-commit-e40e9b1",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",

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

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isConfigEnvMatch = void 0;
-function isConfigEnvMatch(configEnv, isForClientSide, isClientRouting) {
-    if (configEnv === '_routing-eager' || configEnv === 'config-only')
-        return false;
-    if (configEnv === (isForClientSide ? 'server-only' : 'client-only'))
-        return false;
-    if (configEnv === '_routing-lazy' && isForClientSide && !isClientRouting)
-        return false;
-    return true;
-}
-exports.isConfigEnvMatch = isConfigEnvMatch;

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

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

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

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

package/dist/esm/shared/getPageFiles/parsePageConfigsSerialized.d.ts

@@ -1,6 +0,0 @@
-export { parsePageConfigsSerialized };
-import type { PageConfigRuntime, PageConfigGlobalRuntime, PageConfigGlobalRuntimeSerialized, PageConfigRuntimeSerialized } from '../page-configs/PageConfig.js';
-declare function parsePageConfigsSerialized(pageConfigsSerialized: PageConfigRuntimeSerialized[], pageConfigGlobalSerialized: PageConfigGlobalRuntimeSerialized): {
-    pageConfigs: PageConfigRuntime[];
-    pageConfigGlobal: PageConfigGlobalRuntime;
-};