vike 0.4.231 → 0.4.232-commit-134207d

package/dist/esm/node/{plugin/plugins/build → vite/plugins/pluginBuild}/handleAssetsManifest.js

@@ -3,19 +3,18 @@ export { handleAssetsManifest_getBuildConfig };
 export { handleAssetsManifest_isFixEnabled };
 export { handleAssetsManifest_assertUsageCssCodeSplit };
 export { handleAssetsManifest_assertUsageCssTarget };
-import fs from 'fs/promises';
-import fs_sync from 'fs';
-import path from 'path';
-import { existsSync } from 'fs';
-import { assert, assertIsSingleModuleInstance, assertWarning, isEqualStringList, isObject, pLimit, unique } from '../../utils.js';
-import { isVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
+import fs from 'node:fs/promises';
+import fs_sync from 'node:fs';
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+import { assert, assertIsSingleModuleInstance, assertWarning, isEqualStringList, isObject, pLimit, unique, } from '../../utils.js';
+import { isVirtualFileIdPageConfigLazy } from '../../../shared/virtualFiles/virtualFilePageConfigLazy.js';
 import { manifestTempFile } from './pluginBuildConfig.js';
 import { getAssetsDir } from '../../shared/getAssetsDir.js';
 import pc from '@brillout/picocolors';
-import { isV1Design } from '../importUserCode/v1-design/getVikeConfig.js';
+import { getVikeConfigInternal, isV1Design } from '../../shared/resolveVikeConfigInternal.js';
 import { getOutDirs } from '../../shared/getOutDirs.js';
 import { isViteServerBuild_onlySsrEnv, isViteServerBuild } from '../../shared/isViteServerBuild.js';
-import { getVikeConfigInternal } from '../commonConfig.js';
 import { set_macro_ASSETS_MANIFEST } from './pluginBuildEntry.js';
 assertIsSingleModuleInstance('build/handleAssetsManifest.ts');
 let assetsJsonFilePath;
@@ -23,7 +22,7 @@ let assetsJsonFilePath;
 // false => use workaround extractAssets plugin
 function handleAssetsManifest_isFixEnabled(config) {
     // Allow user to toggle between the two workarounds? E.g. based on https://vike.dev/includeAssetsImportedByServer.
-    return isV1Design(config);
+    return isV1Design();
 }
 /** https://github.com/vikejs/vike/issues/1339 */
 async function fixServerAssets(config) {
@@ -52,7 +51,7 @@ async function copyAssets(filesToMove, filesToRemove, config) {
         const filePath = path.posix.join(outDirServer, file);
         fs_sync.unlinkSync(filePath);
     });
-    /* We cannot do that because, with some edge case Rollup settings (outputing JavaScript chunks and static assets to the same directoy), this removes JavaScript chunks, see https://github.com/vikejs/vike/issues/1154#issuecomment-1975762404
+    /* We cannot do that because, with some edge case Rollup settings (outputting JavaScript chunks and static assets to the same directory), this removes JavaScript chunks, see https://github.com/vikejs/vike/issues/1154#issuecomment-1975762404
     await fs.rm(assetsDirServer, { recursive: true })
     */
     removeEmptyDirectories(assetsDirServer);
@@ -154,7 +153,7 @@ function addServerAssets(clientManifest, serverManifest) {
                     css,
                     assets,
                     dynamicImports: undefined,
-                    imports: undefined
+                    imports: undefined,
                 };
             }
         }
@@ -167,12 +166,12 @@ function addServerAssets(clientManifest, serverManifest) {
 }
 function getPageId(key) {
     // Normalize from:
-    //   ../../virtual:vike:pageConfigValuesAll:client:/pages/index
+    //   ../../virtual:vike:pageConfigLazy:client:/pages/index
     // to:
-    //   virtual:vike:pageConfigValuesAll:client:/pages/index
+    //   virtual:vike:pageConfigLazy:client:/pages/index
     // (This seems to be needed only for vitest tests that use Vite's build() API with an inline config.)
     key = key.substring(key.indexOf('virtual:vike'));
-    const result = isVirtualFileIdPageConfigValuesAll(key);
+    const result = isVirtualFileIdPageConfigLazy(key);
     return result && result.pageId;
 }
 function collectResources(entryRoot, manifest) {
@@ -206,7 +205,7 @@ function collectResources(entryRoot, manifest) {
 // </head>
 // ```
 function getHash(src) {
-    // src is guarenteed to end with `.[hash][extname]`, see pluginDistFileNames.ts
+    // src is guaranteed to end with `.[hash][extname]`, see pluginDistFileNames.ts
     const hash = src.split('.').at(-2);
     assert(hash);
     return hash;
@@ -235,10 +234,10 @@ function handleAssetsManifest_assertUsageCssTarget(config) {
                 'The CSS browser target should be the same for both client and server, but we got:',
                 `Client: ${pc.cyan(JSON.stringify(targetCssResolvedClient))}`,
                 `Server: ${pc.cyan(JSON.stringify(targetCssResolvedServer))}`,
-                `Different targets lead to CSS duplication, see ${pc.underline('https://github.com/vikejs/vike/issues/1815#issuecomment-2507002979')} for more information.`
+                `Different targets lead to CSS duplication, see ${pc.underline('https://github.com/vikejs/vike/issues/1815#issuecomment-2507002979')} for more information.`,
             ].join('\n'), {
                 showStackTrace: true,
-                onlyOnce: 'different-css-target'
+                onlyOnce: 'different-css-target',
             });
         });
     });
@@ -280,8 +279,8 @@ async function writeManifestFile(manifest, manifestFilePath) {
     const manifestFileContent = JSON.stringify(manifest, null, 2);
     await fs.writeFile(manifestFilePath, manifestFileContent, 'utf-8');
 }
-function handleAssetsManifest_getBuildConfig(config) {
-    const vike = getVikeConfigInternal(config);
+async function handleAssetsManifest_getBuildConfig(config) {
+    const vikeConfig = await getVikeConfigInternal();
     const isFixEnabled = handleAssetsManifest_isFixEnabled(config);
     return {
         // https://github.com/vikejs/vike/issues/1339
@@ -289,10 +288,10 @@ function handleAssetsManifest_getBuildConfig(config) {
         // Required if `ssrEmitAssets: true`, see https://github.com/vitejs/vite/pull/11430#issuecomment-1454800934
         cssMinify: isFixEnabled ? 'esbuild' : undefined,
         manifest: manifestTempFile,
-        copyPublicDir: vike.config.vite6BuilderApp
+        copyPublicDir: vikeConfig.config.vite6BuilderApp
             ? // Already set by vike:build:pluginBuildApp
                 undefined
-            : !isViteServerBuild(config)
+            : !isViteServerBuild(config),
     };
 }
 async function handleAssetsManifest(config, viteEnv, options, bundle) {
@@ -304,11 +303,13 @@ async function handleAssetsManifest(config, viteEnv, options, bundle) {
         await writeAssetsManifestFile(outDirs, assetsJsonFilePath, config);
     }
     if (isViteServerBuild(config, viteEnv)) {
+        const outDir = options.dir;
+        assert(outDir);
         // Replace __VITE_ASSETS_MANIFEST__ in server builds
         // - Always replace it in dist/server/
         // - Also in some other server builds such as dist/vercel/ from vike-vercel
         // - Don't replace it in dist/rsc/ from vike-react-rsc since __VITE_ASSETS_MANIFEST__ doesn't exist there
-        const noop = await set_macro_ASSETS_MANIFEST(options, bundle, assetsJsonFilePath);
+        const noop = await set_macro_ASSETS_MANIFEST(assetsJsonFilePath, bundle, outDir);
         if (isSsREnv)
             assert(!noop); // dist/server should always contain __VITE_ASSETS_MANIFEST__
     }

package/dist/esm/node/{plugin/plugins/build → vite/plugins/pluginBuild}/pluginAutoFullBuild.js

@@ -2,66 +2,76 @@ export { pluginAutoFullBuild };
 export { isPrerenderForceExit };
 import { build } from 'vite';
 import { assert, assertIsSingleModuleInstance, assertWarning, onSetupBuild } from '../../utils.js';
-import { runPrerenderFromAutoRun, runPrerender_forceExit } from '../../../prerender/runPrerender.js';
-import { isPrerenderAutoRunEnabled } from '../../../prerender/context.js';
+import { isPrerenderAutoRunEnabled, wasPrerenderRun } from '../../../prerender/context.js';
 import { isViteCliCall, getViteConfigFromCli } from '../../shared/isViteCliCall.js';
 import pc from '@brillout/picocolors';
 import { logErrorHint } from '../../../runtime/renderPage/logErrorHint.js';
 import { manifestTempFile } from './pluginBuildConfig.js';
-import { getVikeConfig } from '../importUserCode/v1-design/getVikeConfig.js';
+import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 import { isVikeCliOrApi } from '../../../api/context.js';
 import { handleAssetsManifest, handleAssetsManifest_assertUsageCssTarget } from './handleAssetsManifest.js';
 import { isViteClientBuild, isViteServerBuild_onlySsrEnv } from '../../shared/isViteServerBuild.js';
+import { runPrerender_forceExit, runPrerenderFromAutoRun } from '../../../prerender/runPrerenderEntry.js';
 assertIsSingleModuleInstance('build/pluginAutoFullBuild.ts');
 let forceExit = false;
 function pluginAutoFullBuild() {
     let config;
-    let vikeConfig;
     return [
         {
             name: 'vike:build:pluginAutoFullBuild',
             apply: 'build',
             enforce: 'pre',
             async configResolved(config_) {
-                vikeConfig = await getVikeConfig(config_);
                 config = config_;
-                abortViteBuildSsr(vikeConfig);
+                await abortViteBuildSsr();
             },
             writeBundle: {
-                /* We can't use this because it breaks Vite's logging. TODO/eventually: try again with latest Vite version.
+                /* We can't use this because it breaks Vite's logging. TO-DO/eventually: try again with latest Vite version.
                 sequential: true,
                 order: 'pre',
                 */
                 async handler(options, bundle) {
-                    await handleAssetsManifest(config, this.environment, options, bundle);
-                    await triggerFullBuild(config, vikeConfig, this.environment, bundle);
-                }
-            }
+                    try {
+                        await handleAssetsManifest(config, this.environment, options, bundle);
+                        await triggerFullBuild(config, this.environment, bundle);
+                    }
+                    catch (err) {
+                        // We use try-catch also because:
+                        // - Vite/Rollup swallows errors thrown inside the writeBundle() hook. (It doesn't swallow errors thrown inside the first writeBundle() hook while building the client-side, but it does swallow errors thrown inside the second writeBundle() while building the server-side triggered after Vike calls Vite's `build()` API.)
+                        // - Avoid Rollup prefixing the error with [vike:build:pluginAutoFullBuild], see for example https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
+                        console.error(err);
+                        logErrorHint(err);
+                        process.exit(1);
+                    }
+                },
+            },
         },
         {
-            name: 'vike:build:pluginAutoFullBuild:forceExit',
+            name: 'vike:build:pluginAutoFullBuild:post',
             apply: 'build',
             enforce: 'post',
             closeBundle: {
                 sequential: true,
                 order: 'post',
-                handler() {
+                async handler() {
                     onSetupBuild();
                     handleAssetsManifest_assertUsageCssTarget(config);
+                    const vikeConfig = await getVikeConfigInternal();
                     if (forceExit &&
                         // Let vike:build:pluginBuildApp force exit
-                        !vikeConfig.global.config.vite6BuilderApp) {
+                        !vikeConfig.config.vite6BuilderApp) {
                         runPrerender_forceExit();
                         assert(false);
                     }
-                }
-            }
-        }
+                },
+            },
+        },
     ];
 }
-async function triggerFullBuild(config, vikeConfig, viteEnv, bundle) {
+async function triggerFullBuild(config, viteEnv, bundle) {
+    const vikeConfig = await getVikeConfigInternal();
     // Whether builder.buildApp() is being used, see plugin:build:pluginBuildApp
-    const isBuilderApp = vikeConfig.global.config.vite6BuilderApp;
+    const isBuilderApp = vikeConfig.config.vite6BuilderApp;
     // If builder.buildApp() => trigger at end of `this.environment.name === 'ssr'`.
     // Else => trigger at end of client-side build.
     if (isBuilderApp ? !isViteServerBuild_onlySsrEnv(config, viteEnv) : !isViteClientBuild(config, viteEnv))
@@ -76,22 +86,15 @@ async function triggerFullBuild(config, vikeConfig, viteEnv, bundle) {
         return;
     const configInline = getFullBuildInlineConfig(config);
     if (!isBuilderApp) {
-        try {
-            await build(setSSR(configInline));
-        }
-        catch (err) {
-            // Avoid Rollup prefixing the error with [vike:build:pluginAutoFullBuild], see for example https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
-            console.error(err);
-            logErrorHint(err);
-            process.exit(1);
-        }
+        await build(setSSR(configInline));
     }
     else {
-        // The server bulid is already called by builder.buildApp()
+        // The server build is already called by builder.buildApp()
     }
     if (isPrerenderAutoRunEnabled(vikeConfig)) {
         const res = await runPrerenderFromAutoRun(configInline);
         forceExit = res.forceExit;
+        assert(wasPrerenderRun());
     }
 }
 function setSSR(configInline) {
@@ -99,18 +102,19 @@ function setSSR(configInline) {
         ...configInline,
         build: {
             ...configInline.build,
-            ssr: true
-        }
+            ssr: true,
+        },
     };
 }
-function abortViteBuildSsr(vikeConfig) {
-    if (vikeConfig.global.config.disableAutoFullBuild !== true && isViteCliCall() && getViteConfigFromCli()?.build.ssr) {
+async function abortViteBuildSsr() {
+    const vikeConfig = await getVikeConfigInternal();
+    if (vikeConfig.config.disableAutoFullBuild !== true && isViteCliCall() && getViteConfigFromCli()?.build.ssr) {
         assertWarning(false, `The CLI call ${pc.cyan('$ vite build --ssr')} is superfluous since ${pc.cyan('$ vite build')} also builds the server-side. If you want two separate build steps then use https://vike.dev/disableAutoFullBuild or use Vite's ${pc.cyan('build()')} API.`, { onlyOnce: true });
         process.exit(0);
     }
 }
 function isEntirelyDisabled(vikeConfig) {
-    const { disableAutoFullBuild } = vikeConfig.global.config;
+    const { disableAutoFullBuild } = vikeConfig.config;
     if (disableAutoFullBuild === undefined || disableAutoFullBuild === 'prerender') {
         const isUserUsingViteApi = !isViteCliCall() && !isVikeCliOrApi();
         return isUserUsingViteApi;
@@ -133,8 +137,8 @@ function getFullBuildInlineConfig(config) {
             configFile: configFromCli?.configFile || config.configFile,
             root: config.root,
             build: {
-                ...configFromCli?.build
-            }
+                ...configFromCli?.build,
+            },
         };
     }
 }

package/dist/esm/node/{plugin/plugins/build → vite/plugins/pluginBuild}/pluginBuildApp.js

@@ -1,21 +1,21 @@
 export { pluginBuildApp };
-import { runPrerender_forceExit } from '../../../prerender/runPrerender.js';
+import { runPrerender_forceExit } from '../../../prerender/runPrerenderEntry.js';
 import { resolveOutDir } from '../../shared/getOutDirs.js';
 import { assert } from '../../utils.js';
-import { getVikeConfigInternal } from '../commonConfig.js';
 import { isPrerenderForceExit } from './pluginAutoFullBuild.js';
+import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 function pluginBuildApp() {
     return [
         {
             name: 'vike:build:pluginBuildApp',
             apply: 'build',
-            config(config) {
-                const vike = getVikeConfigInternal(config);
-                if (!vike.config.vite6BuilderApp)
+            async config(config) {
+                const vikeConfig = await getVikeConfigInternal();
+                if (!vikeConfig.config.vite6BuilderApp)
                     return;
                 return {
                     builder: {
-                        // Can be overriden by another plugin e.g vike-vercel https://github.com/vikejs/vike/pull/2184#issuecomment-2659425195
+                        // Can be overridden by another plugin e.g vike-vercel https://github.com/vikejs/vike/pull/2184#issuecomment-2659425195
                         async buildApp(builder) {
                             assert(builder.environments.client);
                             assert(builder.environments.ssr);
@@ -25,26 +25,26 @@ function pluginBuildApp() {
                                 runPrerender_forceExit();
                                 assert(false);
                             }
-                        }
+                        },
                     },
                     environments: {
                         ssr: {
                             consumer: 'server',
                             build: {
                                 outDir: resolveOutDir(config, true),
-                                ssr: true
-                            }
+                                ssr: true,
+                            },
                         },
                         client: {
                             consumer: 'client',
                             build: {
                                 copyPublicDir: true,
-                                ssr: false
-                            }
-                        }
-                    }
+                                ssr: false,
+                            },
+                        },
+                    },
                 };
-            }
-        }
+            },
+        },
     ];
 }

package/dist/esm/node/{plugin/plugins/build → vite/plugins/pluginBuild}/pluginBuildConfig.d.ts

@@ -3,7 +3,7 @@ export { assertRollupInput };
 export { analyzeClientEntries };
 export { manifestTempFile };
 import type { ResolvedConfig, Plugin } from 'vite';
-import type { PageConfigBuildTime } from '../../../../shared/page-configs/PageConfig.js';
+import type { PageConfigBuildTime } from '../../../../types/PageConfig.js';
 declare const manifestTempFile = "_temp_manifest.json";
 declare function pluginBuildConfig(): Plugin[];
 declare function analyzeClientEntries(pageConfigs: PageConfigBuildTime[], config: ResolvedConfig): {

package/dist/esm/node/{plugin/plugins/build → vite/plugins/pluginBuild}/pluginBuildConfig.js

@@ -2,17 +2,18 @@ export { pluginBuildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
 export { manifestTempFile };
-import { assert, addOnBeforeLogHook, removeFileExtention, unique, assertUsage, injectRollupInputs, normalizeRollupInput, onSetupBuild, assertIsImportPathNpmPackage, requireResolveVikeDistFile } from '../../utils.js';
-import { getVikeConfig } from '../importUserCode/v1-design/getVikeConfig.js';
+import { assert, addOnBeforeLogHook, removeFileExtension, unique, assertUsage, injectRollupInputs, normalizeRollupInput, onSetupBuild, assertIsImportPathNpmPackage, requireResolveVikeDistFile, } from '../../utils.js';
+import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 import { findPageFiles } from '../../shared/findPageFiles.js';
-import { getVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
+import { getVirtualFileIdPageConfigLazy } from '../../../shared/virtualFiles/virtualFilePageConfigLazy.js';
 import { extractAssetsAddQuery } from '../../../shared/extractAssetsQuery.js';
 import { prependEntriesDir } from '../../../shared/prependEntriesDir.js';
 import { getFilePathResolved } from '../../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../../shared/page-configs/getConfigValueBuildTime.js';
 import { isViteServerBuild } from '../../shared/isViteServerBuild.js';
 import { resolveOutDir } from '../../shared/getOutDirs.js';
-import { handleAssetsManifest_assertUsageCssCodeSplit, handleAssetsManifest_getBuildConfig } from './handleAssetsManifest.js';
+import { handleAssetsManifest_assertUsageCssCodeSplit, handleAssetsManifest_getBuildConfig, } from './handleAssetsManifest.js';
+import { resolveIncludeAssetsImportedByServer } from '../../../runtime/renderPage/getPageAssets.js';
 const manifestTempFile = '_temp_manifest.json';
 function pluginBuildConfig() {
     let config;
@@ -32,40 +33,38 @@ function pluginBuildConfig() {
                     config.build.rollupOptions.input = injectRollupInputs(entries, config);
                     addLogHook();
                     handleAssetsManifest_assertUsageCssCodeSplit(config);
-                }
+                },
             },
             config: {
                 order: 'post',
-                handler(config) {
+                async handler(config) {
                     onSetupBuild();
                     return {
                         build: {
                             outDir: resolveOutDir(config),
-                            ...handleAssetsManifest_getBuildConfig(config)
-                        }
+                            ...(await handleAssetsManifest_getBuildConfig(config)),
+                        },
                     };
-                }
+                },
             },
             buildStart() {
                 onSetupBuild();
-            }
-        }
+            },
+        },
     ];
 }
 async function getEntries(config) {
-    const vikeConfig = await getVikeConfig(config);
-    const { pageConfigs } = vikeConfig;
+    const vikeConfig = await getVikeConfigInternal();
+    const { _pageConfigs: pageConfigs } = vikeConfig;
     // TODO/v1-release: remove
-    const pageFileEntries = await getPageFileEntries(config, 
-    // TODO/now: add meta.default
-    vikeConfig.global.config.includeAssetsImportedByServer ?? true);
+    const pageFileEntries = await getPageFileEntries(config, resolveIncludeAssetsImportedByServer(vikeConfig.config));
     assertUsage(Object.keys(pageFileEntries).length !== 0 || pageConfigs.length !== 0, 'At least one page should be defined, see https://vike.dev/add');
     if (isViteServerBuild(config)) {
         const pageEntries = getPageEntries(pageConfigs);
         const entries = {
             ...pageFileEntries,
             // Ensure Rollup generates a bundle per page: https://github.com/vikejs/vike/issues/349#issuecomment-1166247275
-            ...pageEntries
+            ...pageEntries,
         };
         return entries;
     }
@@ -77,10 +76,10 @@ async function getEntries(config) {
         }
         const entries = {
             ...clientEntries,
-            ...pageFileEntries
+            ...pageFileEntries,
         };
-        const clientRoutingEntry = requireResolveVikeDistFile('dist/esm/client/client-routing-runtime/entry.js');
-        const serverRoutingEntry = requireResolveVikeDistFile('dist/esm/client/server-routing-runtime/entry.js');
+        const clientRoutingEntry = requireResolveVikeDistFile('dist/esm/client/runtime-client-routing/entry.js');
+        const serverRoutingEntry = requireResolveVikeDistFile('dist/esm/client/runtime-server-routing/entry.js');
         if (hasClientRouting) {
             entries['entries/entry-client-routing'] = clientRoutingEntry;
         }
@@ -163,7 +162,7 @@ function getEntryFromClientEntry(clientEntry, config, addExtractAssetsQuery) {
     assert(filePathAbsoluteUserRootDir.startsWith('/'));
     const filePath = getFilePathResolved({
         filePathAbsoluteUserRootDir,
-        userRootDir: config.root
+        userRootDir: config.root,
     });
     let entryTarget = filePath.filePathAbsoluteFilesystem;
     if (addExtractAssetsQuery)
@@ -171,13 +170,13 @@ function getEntryFromClientEntry(clientEntry, config, addExtractAssetsQuery) {
     let entryName = filePathAbsoluteUserRootDir;
     if (addExtractAssetsQuery)
         entryName = extractAssetsAddQuery(entryName);
-    entryName = removeFileExtention(entryName);
+    entryName = removeFileExtension(entryName);
     entryName = prependEntriesDir(entryName);
     return { entryName, entryTarget };
 }
 function getEntryFromPageConfig(pageConfig, isForClientSide) {
     let { pageId } = pageConfig;
-    const entryTarget = getVirtualFileIdPageConfigValuesAll(pageId, isForClientSide);
+    const entryTarget = getVirtualFileIdPageConfigLazy(pageId, isForClientSide);
     let entryName = pageId;
     // Avoid:
     // ```

package/dist/esm/node/{plugin/plugins/build → vite/plugins/pluginBuild}/pluginBuildEntry.d.ts

@@ -2,6 +2,5 @@ export { pluginBuildEntry };
 export { set_macro_ASSETS_MANIFEST };
 import type { Plugin, Rollup } from 'vite';
 type Bundle = Rollup.OutputBundle;
-type Options = Rollup.NormalizedOutputOptions;
 declare function pluginBuildEntry(): Plugin[];
-declare function set_macro_ASSETS_MANIFEST(options: Options, bundle: Bundle, assetsJsonFilePath: string | undefined): Promise<boolean>;
+declare function set_macro_ASSETS_MANIFEST(assetsJsonFilePath: string | undefined, bundle: Bundle, outDir: string): Promise<boolean>;

package/dist/esm/node/{plugin/plugins/build → vite/plugins/pluginBuild}/pluginBuildEntry.js

@@ -1,11 +1,11 @@
 export { pluginBuildEntry };
 export { set_macro_ASSETS_MANIFEST };
 import { serverProductionEntryPlugin } from '@brillout/vite-plugin-server-entry/plugin';
-import { virtualFileIdImportUserCodeServer } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
+import { virtualFileIdEntryServer } from '../../../shared/virtualFiles/virtualFileEntry.js';
 import { assert, PROJECT_VERSION, requireResolveVikeDistFile } from '../../utils.js';
-import fs from 'fs/promises';
-import path from 'path';
-import { isUsingClientRouter } from '../extractExportNamesPlugin.js';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { isUsingClientRouter } from '../pluginExtractExportNames.js';
 import { assertBuildInfo } from '../../../runtime/globalContext.js';
 import { getOutDirs } from '../../shared/getOutDirs.js';
 import { getViteConfigRuntime } from '../../shared/getViteConfigRuntime.js';
@@ -19,14 +19,14 @@ function pluginBuildEntry() {
             enforce: 'post',
             async configResolved(config_) {
                 config = config_;
-            }
+            },
         },
         ...serverProductionEntryPlugin({
             getServerProductionEntry: () => {
                 return getServerProductionEntryCode(config);
             },
-            libraryName: 'Vike'
-        })
+            libraryName: 'Vike',
+        }),
     ];
 }
 function getServerProductionEntryCode(config) {
@@ -34,13 +34,13 @@ function getServerProductionEntryCode(config) {
     const buildInfo = {
         versionAtBuildTime: PROJECT_VERSION,
         usesClientRouter: isUsingClientRouter(), // TODO/v1-release: remove
-        viteConfigRuntime: getViteConfigRuntime(config)
+        viteConfigRuntime: getViteConfigRuntime(config),
     };
     assertBuildInfo(buildInfo);
     // After the old design is removed, let's maybe simplify and move everything into a single virtual module
     const importerCode = [
         `  import { setGlobalContext_buildEntry } from '${importPath}';`,
-        `  import * as virtualFileExports from '${virtualFileIdImportUserCodeServer}';`,
+        `  import * as virtualFileExports from '${virtualFileIdEntryServer}';`,
         `  {`,
         // Because of a Rollup bug, we have to assign ASSETS_MANIFEST to a variable before passing it to setGlobalContext_buildEntry()
         // - This workaround doesn't work: https://github.com/vikejs/vike/commit/d5f3a4f7aae5a8bc44192e6cbb2bcb9007be188d
@@ -52,14 +52,13 @@ function getServerProductionEntryCode(config) {
         `      buildInfo,`,
         '    });',
         `  }`,
-        ''
+        '',
     ].join('\n');
     return importerCode;
 }
 // Set the value of the ASSETS_MANIFEST constant inside dist/server/entry.js (or dist/server/index.js)
-async function set_macro_ASSETS_MANIFEST(options, bundle, assetsJsonFilePath) {
-    const { dir } = options;
-    assert(dir);
+async function set_macro_ASSETS_MANIFEST(assetsJsonFilePath, bundle, outDir) {
+    assert(outDir);
     const chunkPath = find_ASSETS_MANIFEST(bundle);
     // Some server builds don't contain __VITE_ASSETS_MANIFEST__ such as dist/rsc/ from vike-react-rsc
     if (!chunkPath) {
@@ -67,10 +66,10 @@ async function set_macro_ASSETS_MANIFEST(options, bundle, assetsJsonFilePath) {
         return noop;
     }
     assert(assetsJsonFilePath);
-    const chunkFilePath = path.join(dir, chunkPath);
+    const chunkFilePath = path.join(outDir, chunkPath);
     const [assetsJsonString, chunkFileContent] = await Promise.all([
         await fs.readFile(assetsJsonFilePath, 'utf8'),
-        await fs.readFile(chunkFilePath, 'utf8')
+        await fs.readFile(chunkFilePath, 'utf8'),
     ]);
     const serverEntryFileContentPatched = chunkFileContent.replace(ASSETS_MANIFEST, assetsJsonString);
     assert(serverEntryFileContentPatched !== chunkFileContent);

package/dist/esm/node/{plugin/plugins/build → vite/plugins/pluginBuild}/pluginDistFileNames.js

@@ -3,8 +3,8 @@ export { pluginDistFileNames };
 //  - https://github.com/vikejs/vike/commit/11a4c49e5403aa7c37c8020c462b499425b41854
 //  - Blocker: https://github.com/rollup/rollup/issues/4724
 import { assertPosixPath, assert, assertUsage, isArray, isCallable } from '../../utils.js';
-import path from 'path';
-import crypto from 'crypto';
+import path from 'node:path';
+import crypto from 'node:crypto';
 import { getAssetsDir } from '../../shared/getAssetsDir.js';
 import { assertModuleId, getModuleFilePathAbsolute } from '../../shared/getFilePath.js';
 function pluginDistFileNames() {
@@ -14,7 +14,7 @@ function pluginDistFileNames() {
         enforce: 'post',
         configResolved(config) {
             const rollupOutputs = getRollupOutputs(config);
-            // We need to support multiple outputs: @vite/plugin-legacy adds an ouput, see https://github.com/vikejs/vike/issues/477#issuecomment-1406434802
+            // We need to support multiple outputs: @vite/plugin-legacy adds an output, see https://github.com/vikejs/vike/issues/477#issuecomment-1406434802
             rollupOutputs.forEach((rollupOutput) => {
                 if (!('entryFileNames' in rollupOutput)) {
                     rollupOutput.entryFileNames = (chunkInfo) => getEntryFileName(chunkInfo, config, true);
@@ -24,6 +24,8 @@ function pluginDistFileNames() {
                 }
                 if (!('assetFileNames' in rollupOutput)) {
                     rollupOutput.assetFileNames = (chunkInfo) => getAssetFileName(chunkInfo, config);
+                    rollupOutput.assetFileNames.isTheOneSetByVike = true;
+                    assert(rollupOutput.assetFileNames.isTheOneSetByVike);
                 }
                 else {
                     // If a user needs this:
@@ -31,7 +33,7 @@ function pluginDistFileNames() {
                     //    - It's needed for getHash() of handleAssetsManifest()
                     //    - Asset URLs should always contain a hash: it's paramount for caching assets.
                     //    - If rollupOutput.assetFileNames is a function then use a wrapper function to apply the assertUsage()
-                    assertUsage(false, "Setting Vite's configuration build.rollupOptions.output.assetFileNames is currently forbidden. Reach out if you need to use.");
+                    assertUsage(rollupOutput.assetFileNames.isTheOneSetByVike, "Setting Vite's configuration build.rollupOptions.output.assetFileNames is currently forbidden. Reach out if you need to use it.");
                 }
                 {
                     const manualChunksOriginal = rollupOutput.manualChunks;
@@ -92,7 +94,7 @@ function pluginDistFileNames() {
                     };
                 }
             });
-        }
+        },
     };
 }
 function getIdHash(id) {
@@ -147,7 +149,7 @@ function getEntryFileName(chunkInfo, config, isEntry) {
         return `${name}.${isEntry ? 'mjs' : 'js'}`;
     }
 }
-function removePathSeperators(name) {
+function removePathSeparators(name) {
     assertPosixPath(name);
     assert(!name.startsWith('/'));
     const entryDir = 'entries/';
@@ -167,9 +169,9 @@ function clean(name, removePathSep, fixGlob) {
     if (fixGlob) {
         name = workaroundGlob(name);
     }
-    name = replaceNonLatinCharaters(name);
+    name = replaceNonLatinCharacters(name);
     if (removePathSep) {
-        name = removePathSeperators(name);
+        name = removePathSeparators(name);
     }
     name = removeLeadingUnderscoreInFilename(name);
     name = removeUnderscoreDoublets(name);
@@ -189,7 +191,7 @@ function removeUnderscoreDoublets(name) {
     name = name.split(/__+/).join('_');
     return name;
 }
-function replaceNonLatinCharaters(name) {
+function replaceNonLatinCharacters(name) {
     name = name.split('+').join('');
     name = name.replace(/[^a-zA-Z0-9\/\._]/g, '-');
     return name;