vike 0.4.143 → 0.4.144-commit-e40e9b1

package/dist/esm/client/shared/preparePageContextForUserConsumptionClientSide.d.ts

@@ -1,11 +1,11 @@
 export { preparePageContextForUserConsumptionClientSide };
 export type { PageContextForUserConsumptionClientSide };
 import type { PageContextExports } from '../../shared/getPageFiles.js';
-import type { PageConfig } from '../../shared/page-configs/PageConfig.js';
+import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
 import { PageContextForPassToClientWarning } from './getPageContextProxyForUser.js';
 type PageContextForUserConsumptionClientSide = PageContextExports & PageContextForPassToClientWarning & {
     _pageId: string;
-    _pageConfigs: PageConfig[];
+    _pageConfigs: PageConfigRuntime[];
 };
 declare function preparePageContextForUserConsumptionClientSide<T extends PageContextForUserConsumptionClientSide>(pageContext: T, isClientRouting: boolean): T & {
     Page: unknown;

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

@@ -1,5 +1,6 @@
 export default plugin;
 export { plugin };
+// TODO/v1-release: remove
 export { plugin as ssr };
 import { assertUsage, markEnvAsVite } from './utils.js';
 import { buildConfig } from './plugins/buildConfig.js';
@@ -48,7 +49,7 @@ function plugin(vikeConfig) {
     ];
     return plugins;
 }
-// Enable `const ssr = require('vike/plugin')`.
+// Enable `const vike = require('vike/plugin')`.
 //  - This lives at the end of the file to ensure it happens after all assignments to `exports`.
 //  - This is only used for the CJS build; we wrap it in a try-catch for the ESM build.
 try {
@@ -59,6 +60,6 @@ catch { }
 Object.defineProperty(plugin, 'apply', {
     enumerable: true,
     get: () => {
-        assertUsage(false, `Add ${pc.cyan('ssr()')} instead of ${pc.cyan('ssr')} to vite.config.js#plugins (i.e. call the function and add the return value instead of adding the function itself)`, { showStackTrace: true });
+        assertUsage(false, `Add ${pc.cyan('vike()')} instead of ${pc.cyan('vike')} to vite.config.js#plugins (i.e. call the function and add the return value instead of adding the function itself)`, { showStackTrace: true });
     }
 });

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

@@ -1,7 +1,7 @@
 export { buildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
-import { assert, resolveOutDir, isObject, viteIsSSR, getFilePathAbsolute, addOnBeforeLogHook, removeFileExtention, unique, assertPosixPath, assertUsage } from '../utils.js';
+import { assert, resolveOutDir, isObject, viteIsSSR, getFilePathAbsolute, addOnBeforeLogHook, removeFileExtention, unique, assertPosixPath, assertUsage, getOutDirs, } from '../utils.js';
 import { virtualFileIdImportUserCodeServer } from '../../shared/virtual-files/virtualFileImportUserCode.js';
 import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
 import { getConfigValue } from '../../../shared/page-configs/utils.js';
@@ -69,7 +69,7 @@ function buildConfig() {
 async function getEntries(config) {
     const configVike = await getConfigVike(config);
     const pageFileEntries = await getPageFileEntries(config, configVike.includeAssetsImportedByServer); // TODO/v1-release: remove
-    const { pageConfigs } = await getVikeConfig(config.root, false, configVike.extensions);
+    const { pageConfigs } = await getVikeConfig(config.root, getOutDirs(config).outDirRoot, false, configVike.extensions);
     assertUsage(Object.keys(pageFileEntries).length !== 0 || pageConfigs.length !== 0, 'At least one page should be defined, see https://vike.dev/add');
     if (viteIsSSR(config)) {
         const serverEntries = analyzeServerEntries(pageConfigs);

package/dist/esm/node/plugin/plugins/config/index.js

@@ -1,6 +1,6 @@
 export { resolveVikeConfig };
 import { assertVikeConfig } from './assertVikeConfig.js';
-import { isDev2 } from '../../utils.js';
+import { getOutDirs, isDev2 } from '../../utils.js';
 import { findConfigVikeFromStemPackages } from './findConfigVikeFromStemPackages.js';
 import { pickFirst } from './pickFirst.js';
 import { resolveExtensions } from './resolveExtensions.js';
@@ -24,7 +24,7 @@ async function resolveConfig(vikeConfig, config) {
     const fromStemPackages = await findConfigVikeFromStemPackages(config.root);
     const configs = [fromPluginOptions, ...fromStemPackages, fromViteConfig];
     const extensions = resolveExtensions(configs, config);
-    const { globalVikeConfig: fromPlusConfigFile } = await getVikeConfig(config.root, isDev2(config), extensions);
+    const { globalVikeConfig: fromPlusConfigFile } = await getVikeConfig(config.root, getOutDirs(config).outDirRoot, isDev2(config), extensions);
     configs.push(fromPlusConfigFile);
     assertVikeConfig(fromPlusConfigFile, ({ prop, errMsg }) => {
         // TODO: add config file path ?

package/dist/esm/node/plugin/plugins/devConfig/determineOptimizeDeps.js

@@ -1,12 +1,12 @@
 export { determineOptimizeDeps };
 import { findPageFiles } from '../../shared/findPageFiles.js';
-import { assert, getFilePathAbsolute, isNotNullish, isNpmPackageImport, unique } from '../../utils.js';
+import { assert, getFilePathAbsolute, getOutDirs, isNotNullish, isNpmPackageImport, unique } from '../../utils.js';
 import { getVikeConfig } from '../importUserCode/v1-design/getVikeConfig.js';
-import { getConfigValueSourcesRelevant } from '../../shared/getConfigValueSource.js';
+import { getConfigValueSourcesRelevant } from '../../shared/getConfigValueSourcesRelevant.js';
 import { analyzeClientEntries } from '../buildConfig.js';
 import { virtualFileIdImportUserCodeClientCR, virtualFileIdImportUserCodeClientSR } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
 async function determineOptimizeDeps(config, configVike, isDev) {
-    const { pageConfigs } = await getVikeConfig(config.root, isDev, configVike.extensions);
+    const { pageConfigs } = await getVikeConfig(config.root, getOutDirs(config).outDirRoot, isDev, configVike.extensions);
     const { entries, include } = await getPageDeps(config, pageConfigs, isDev);
     {
         // This actually doesn't work: Vite's dep optimizer doesn't seem to be able to crawl virtual files.
@@ -22,7 +22,7 @@ async function determineOptimizeDeps(config, configVike, isDev) {
     */
     config.optimizeDeps.include = [...include, ...normalizeInclude(config.optimizeDeps.include)];
     config.optimizeDeps.entries = [...entries, ...normalizeEntries(config.optimizeDeps.entries)];
-    // console.log('config.optimizeDeps', config.optimizeDeps)
+    // console.log('config.optimizeDeps', { entries: config.optimizeDeps.entries, include: config.optimizeDeps.include })
 }
 async function getPageDeps(config, pageConfigs, isDev) {
     let entries = [];
@@ -32,37 +32,38 @@ async function getPageDeps(config, pageConfigs, isDev) {
         pageConfigs.forEach((pageConfig) => {
             const configValueSourcesRelevant = getConfigValueSourcesRelevant(pageConfig);
             configValueSourcesRelevant.forEach((configValueSource) => {
-                const { valueIsImportedAtRuntime, configEnv, definedAtInfo } = configValueSource;
-                if (!valueIsImportedAtRuntime)
+                if (!configValueSource.valueIsImportedAtRuntime)
                     return;
-                const { filePath } = definedAtInfo;
-                assert(filePath);
+                const { definedAtInfo, configEnv } = configValueSource;
                 if (configEnv !== 'client-only' && configEnv !== 'server-and-client')
                     return;
-                if (filePath.startsWith('/')) {
-                    // Is getFilePathAbsolute() really needed? This contradicts the code below that doesn't need getFilePathAbsolute().
-                    entries.push(getFilePathAbsolute(filePath, config));
-                    return;
-                }
-                // getVikeConfig() resolves relative import paths
-                assert(!filePath.startsWith('.'));
-                // We need to differentiate between npm package imports and path aliases.
-                // There are path aliases that cannot be distinguished from npm package names.
-                // We recommend users to use the '#' prefix convention for path aliases, see https://vike.dev/path-aliases#vite and assertResolveAlias()
-                if (isNpmPackageImport(filePath)) {
-                    // isNpmPackageImport() returns false for a path alias like #root/renderer/onRenderClient
-                    assert(!filePath.startsWith('#'));
-                    include.push(filePath);
+                if (definedAtInfo.filePathRelativeToUserRootDir !== null) {
+                    const { filePathAbsolute } = definedAtInfo;
+                    assert(filePathAbsolute);
+                    // Surprisingly Vite expects entries to be absolute paths
+                    entries.push(filePathAbsolute);
                 }
                 else {
-                    /* Path aliases, e.g.:
-                     * ```js
-                     * // /renderer/+config.js
-                     * import onRenderClient from '#root/renderer/onRenderClient'
-                     * ```
-                     * Does Vite resolve the path aliases or is getFilePathAbsolute() needed?
-                     */
-                    entries.push(filePath);
+                    // Adding definedAtInfo.filePathAbsolute doesn't work for npm packages, I guess because of Vite's config.server.fs.allow
+                    const { importPathAbsolute } = definedAtInfo;
+                    assert(importPathAbsolute);
+                    // We need to differentiate between npm package imports and path aliases.
+                    // There are path aliases that cannot be distinguished from npm package names.
+                    // We recommend users to use the '#' prefix convention for path aliases, see https://vike.dev/path-aliases#vite and assertResolveAlias()
+                    if (isNpmPackageImport(importPathAbsolute)) {
+                        // isNpmPackageImport() returns false for a path alias like #root/renderer/onRenderClient
+                        assert(!importPathAbsolute.startsWith('#'));
+                        include.push(importPathAbsolute);
+                    }
+                    else {
+                        /* Path aliases, e.g.:
+                         * ```js
+                         * // /renderer/+config.js
+                         * import onRenderClient from '#root/renderer/onRenderClient'
+                         * ```
+                         */
+                        entries.push(importPathAbsolute);
+                    }
                 }
             });
         });

package/dist/esm/node/plugin/plugins/importUserCode/generateEagerImport.d.ts

@@ -1,5 +1,16 @@
 export { generateEagerImport };
-declare function generateEagerImport(importPath: string, varCounter?: number, importName?: string): {
-    importVar: string;
+/**
+ * Naming:
+ *   `import { someExport as someImport } from './some-file'`
+ * <=>
+ *   `{`
+ *      `importPath: './some-file',`
+ *      `exportName: 'someExport',`
+ *      `importName: 'someImport',`
+ *    `}`
+ * We discard the information that the import variable is called `someImport` because we don't need it.
+ */
+declare function generateEagerImport(importPath: string, varCounter?: number, exportName?: string): {
+    importName: string;
     importStatement: string;
 };

package/dist/esm/node/plugin/plugins/importUserCode/generateEagerImport.js

@@ -1,18 +1,29 @@
 export { generateEagerImport };
 let varCounterGlobal = 0;
-function generateEagerImport(importPath, varCounter, importName) {
+/**
+ * Naming:
+ *   `import { someExport as someImport } from './some-file'`
+ * <=>
+ *   `{`
+ *      `importPath: './some-file',`
+ *      `exportName: 'someExport',`
+ *      `importName: 'someImport',`
+ *    `}`
+ * We discard the information that the import variable is called `someImport` because we don't need it.
+ */
+function generateEagerImport(importPath, varCounter, exportName) {
     if (varCounter === undefined)
         varCounter = varCounterGlobal++;
-    const importVar = `import_${varCounter}`;
+    const importName = `import_${varCounter}`;
     const importLiteral = (() => {
-        if (!importName || importName === '*') {
-            return `* as ${importVar}`;
+        if (!exportName || exportName === '*') {
+            return `* as ${importName}`;
         }
-        if (importName === 'default') {
-            return importVar;
+        if (exportName === 'default') {
+            return importName;
         }
-        return `{ ${importName} as ${importVar} }`;
+        return `{ ${exportName} as ${importName} }`;
     })();
     const importStatement = `import ${importLiteral} from '${importPath}';`;
-    return { importVar, importStatement };
+    return { importName, importStatement };
 }

package/dist/esm/node/plugin/plugins/importUserCode/getVirtualFileImportUserCode.js

@@ -1,5 +1,5 @@
 export { getVirtualFileImportUserCode };
-import { assert, assertPosixPath, viteIsSSR_options, isNotNullish, scriptFileExtensions, debugGlob } from '../../utils.js';
+import { assert, assertPosixPath, viteIsSSR_options, isNotNullish, scriptFileExtensions, debugGlob, getOutDirs } from '../../utils.js';
 import { isVirtualFileIdImportUserCode } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
 import { fileTypes, determineFileType } from '../../../../shared/getPageFiles/fileTypes.js';
 import path from 'path';
@@ -121,9 +121,9 @@ function addImport(importPath, fileType, exportNames, isBuild) {
             return `() => import('${importPath}${query}')`;
         }
         else {
-            const { importVar, importStatement } = generateEagerImport(`${importPath}${query}`);
+            const { importName, importStatement } = generateEagerImport(`${importPath}${query}`);
             fileContent += importStatement + '\n';
-            return importVar;
+            return importName;
         }
     })();
     fileContent += `${mapVar}['${importPath}'] = ${value};\n`;
@@ -140,7 +140,7 @@ export const pageFilesList = [];
 export const neverLoaded = {};
 export const isGeneratedFile = true;
 
-${await getVirtualFilePageConfigs(config.root, isForClientSide, isDev, id, configVike, isClientRouting)}
+${await getVirtualFilePageConfigs(config.root, getOutDirs(config).outDirRoot, isForClientSide, isDev, id, configVike, isClientRouting)}
 
 `;
     fileTypes
@@ -204,10 +204,12 @@ function getGlobs(globRoots, isBuild, fileType, query) {
         ...globRoots.map((globRoot, i) => {
             const varNameLocal = `${varName}${i + 1}`;
             varNameLocals.push(varNameLocal);
-            const globPath = `'${getGlobPath(globRoot, fileType)}'`;
+            const globIncludePath = `'${getGlobPath(globRoot.includeDir, fileType)}'`;
+            const globExcludePath = globRoot.excludeDir ? `'!${getGlobPath(globRoot.excludeDir, fileType)}'` : null;
             const globOptions = JSON.stringify({ eager: isEager, as: query });
             assert(globOptions.startsWith('{"eager":true') || globOptions.startsWith('{"eager":false'));
-            const globLine = `const ${varNameLocal} = import.meta.glob(${globPath}, ${globOptions});`;
+            const globPaths = globExcludePath ? `[${globIncludePath}, ${globExcludePath}]` : `[${globIncludePath}]`;
+            const globLine = `const ${varNameLocal} = import.meta.glob(${globPaths}, ${globOptions});`;
             return globLine;
         }),
         `const ${varName} = {${varNameLocals.map((varNameLocal) => `...${varNameLocal}`).join(',')}};`,
@@ -216,19 +218,26 @@ function getGlobs(globRoots, isBuild, fileType, query) {
     ].join('\n');
 }
 function getGlobRoots(config, configVike) {
-    const globRoots = ['/'];
+    const globRoots = [
+        {
+            includeDir: '/',
+            excludeDir: path.posix.relative(config.root, getOutDirs(config).outDirRoot)
+        }
+    ];
     configVike.extensions
         .map(({ pageConfigsSrcDir }) => pageConfigsSrcDir)
         .filter(isNotNullish)
         .forEach((pageConfigsSrcDir) => {
-        const globRoot = path.posix.relative(config.root, pageConfigsSrcDir);
+        const globRoot = {
+            includeDir: path.posix.relative(config.root, pageConfigsSrcDir)
+        };
         globRoots.push(globRoot);
     });
     return globRoots;
 }
-function getGlobPath(globRoot, fileType) {
-    assertPosixPath(globRoot);
-    let globPath = [...globRoot.split('/'), '**', `*${fileType}.${scriptFileExtensions}`].filter(Boolean).join('/');
+function getGlobPath(globRootDir, fileType) {
+    assertPosixPath(globRootDir);
+    let globPath = [...globRootDir.split('/'), '**', `*${fileType}.${scriptFileExtensions}`].filter(Boolean).join('/');
     if (!globPath.startsWith('/')) {
         globPath = '/' + globPath;
     }

package/dist/esm/node/plugin/plugins/importUserCode/index.js

@@ -3,7 +3,7 @@ import { normalizePath } from 'vite';
 import { getConfigVike } from '../../../shared/getConfigVike.js';
 import { getVirtualFilePageConfigValuesAll } from './v1-design/getVirtualFilePageConfigValuesAll.js';
 import { getVirtualFileImportUserCode } from './getVirtualFileImportUserCode.js';
-import { assert, assertPosixPath, getFilePathRelativeToUserRootDir, getVirtualFileId, isDev1, isDev1_onConfigureServer, isVirtualFileId, resolveVirtualFileId } from '../../utils.js';
+import { assert, assertPosixPath, getFilePathRelativeToUserRootDir, getOutDirs, getVirtualFileId, isDev1, isDev1_onConfigureServer, isVirtualFileId, resolveVirtualFileId } from '../../utils.js';
 import { isVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { isVirtualFileIdImportUserCode } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
 import { vikeConfigDependencies, reloadVikeConfig, isVikeConfigFile } from './v1-design/getVikeConfig.js';
@@ -47,7 +47,7 @@ function importUserCode() {
                 return undefined;
             id = getVirtualFileId(id);
             if (isVirtualFileIdPageConfigValuesAll(id)) {
-                const code = await getVirtualFilePageConfigValuesAll(id, config.root, isDev, configVike);
+                const code = await getVirtualFilePageConfigValuesAll(id, config.root, getOutDirs(config).outDirRoot, isDev, configVike);
                 return code;
             }
             if (isVirtualFileIdImportUserCode(id)) {
@@ -120,7 +120,7 @@ function reloadConfig(filePath, config, configVike, op) {
         const msg = `${op} ${filePathToShowToUser}`;
         logConfigInfo(msg, 'info');
     }
-    reloadVikeConfig(config.root, configVike.extensions);
+    reloadVikeConfig(config.root, getOutDirs(config).outDirRoot, configVike.extensions);
 }
 function getVirtualModules(server) {
     const virtualModules = Array.from(server.moduleGraph.urlToModuleMap.keys())

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

@@ -1,7 +1,24 @@
 export { getFilePathToShowToUser };
 export type { FilePath };
 type FilePath = {
+    /** The file's path relative to the filesystem root.
+     *
+     * Example: `/home/rom/code/my-app/pages/some-page/Page.js`
+     */
     filePathAbsolute: string;
-    filePathRelativeToUserRootDir: null | string;
-};
+} & ({
+    /** The file's path relative to the Vite's root (i.e. the user's project root directory).
+     *
+     * Example: `/pages/some-page/Page.js`
+     */
+    filePathRelativeToUserRootDir: string;
+    importPathAbsolute: null;
+} | {
+    filePathRelativeToUserRootDir: null;
+    /** The file's absolute import path.
+     *
+     * Example: `vike-react/config`
+     */
+    importPathAbsolute: string;
+});
 declare function getFilePathToShowToUser(filePath: FilePath): string;

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

@@ -1,5 +1,11 @@
 export { getFilePathToShowToUser };
 import { assert } from '../../../utils.js';
+/*
+const f: FilePath = 1 as any
+if (f.filePathRelativeToUserRootDir === null) {
+  f.importPathAbsolute
+}
+//*/
 function getFilePathToShowToUser(filePath) {
     const filePathToShowToUser = filePath.filePathRelativeToUserRootDir ?? filePath.filePathAbsolute;
     assert(filePathToShowToUser);

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

@@ -4,7 +4,7 @@ export type { ConfigDefinition };
 export type { ConfigDefinitionInternal };
 export type { ConfigNameGlobal };
 export type { ConfigEffect };
-import type { ConfigEnvInternal, ConfigEnv, PageConfigBuildTime } from '../../../../../../shared/page-configs/PageConfig.js';
+import type { ConfigEnvInternal, ConfigEnv, ConfigValueSources } from '../../../../../../shared/page-configs/PageConfig.js';
 import type { Config, ConfigNameBuiltIn } from '../../../../../../shared/page-configs/Config.js';
 /** The meta definition of a config.
  *
@@ -31,19 +31,20 @@ type ConfigDefinition = {
     effect?: ConfigEffect;
 };
 type ConfigEffect = (config: {
-    /** The resolved config value.
+    /** The config value.
      *
      * https://vike.dev/meta
      */
     configValue: unknown;
-    /** Place where the resolved config value comes from.
+    /** Where the config value is defined.
      *
      * https://vike.dev/meta
      */
     configDefinedAt: `Config ${string}`;
 }) => Config | undefined;
+/** For Vike internal use */
 type ConfigDefinitionInternal = Omit<ConfigDefinition, 'env'> & {
-    _computed?: (pageConfig: PageConfigBuildTime) => unknown;
+    _computed?: (configValueSources: ConfigValueSources) => unknown;
     _valueIsFilePath?: true;
     env: ConfigEnvInternal;
 };

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

@@ -67,13 +67,13 @@ const configDefinitionsBuiltIn = {
     },
     isClientSideRenderable: {
         env: 'server-and-client',
-        _computed: (pageConfig) => isConfigSet(pageConfig, 'onRenderClient') &&
-            isConfigSet(pageConfig, 'Page') &&
-            getConfigEnv(pageConfig, 'Page') !== 'server-only'
+        _computed: (configValueSources) => isConfigSet(configValueSources, 'onRenderClient') &&
+            isConfigSet(configValueSources, 'Page') &&
+            getConfigEnv(configValueSources, 'Page') !== 'server-only'
     },
     onBeforeRenderEnv: {
         env: 'client-only',
-        _computed: (pageConfig) => !isConfigSet(pageConfig, 'onBeforeRender') ? null : getConfigEnv(pageConfig, 'onBeforeRender')
+        _computed: (configValueSources) => !isConfigSet(configValueSources, 'onBeforeRender') ? null : getConfigEnv(configValueSources, 'onBeforeRender')
     }
 };
 const configDefinitionsBuiltInGlobal = {

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

@@ -2,14 +2,14 @@ export { getVikeConfig };
 export { reloadVikeConfig };
 export { vikeConfigDependencies };
 export { isVikeConfigFile };
-import type { PageConfigGlobalData, PageConfigBuildTime } from '../../../../../shared/page-configs/PageConfig.js';
+import type { PageConfigGlobalBuildTime, PageConfigBuildTime } from '../../../../../shared/page-configs/PageConfig.js';
 import type { ExtensionResolved } from '../../../../../shared/ConfigVike.js';
 type VikeConfig = {
     pageConfigs: PageConfigBuildTime[];
-    pageConfigGlobal: PageConfigGlobalData;
+    pageConfigGlobal: PageConfigGlobalBuildTime;
     globalVikeConfig: Record<string, unknown>;
 };
 declare const vikeConfigDependencies: Set<string>;
-declare function reloadVikeConfig(userRootDir: string, extensions: ExtensionResolved[]): void;
-declare function getVikeConfig(userRootDir: string, isDev: boolean, extensions: ExtensionResolved[], tolerateInvalidConfig?: boolean): Promise<VikeConfig>;
+declare function reloadVikeConfig(userRootDir: string, outDirRoot: string, extensions: ExtensionResolved[]): void;
+declare function getVikeConfig(userRootDir: string, outDirRoot: string, isDev: boolean, extensions: ExtensionResolved[], tolerateInvalidConfig?: boolean): Promise<VikeConfig>;
 declare function isVikeConfigFile(filePath: string): boolean;