vike 0.4.239-commit-33e55d4 → 0.4.239-commit-4d0d950

package/dist/esm/client/runtime-client-routing/entry.js

@@ -3,9 +3,14 @@ assertClientRouting();
 import { initClientRouter } from './initClientRouter.js';
 import { assertSingleInstance_onClientEntryClientRouting } from './utils.js';
 import { removeFoucBuster } from '../shared/removeFoucBuster.js';
+import { setVirtualFileExportsGlobalEntry } from '../shared/createGetGlobalContextClient.js';
+// @ts-expect-error
+import * as virtualFileExportsGlobalEntry from 'virtual:vike:global-entry:client:client-routing';
+// TODO/now: remove this ts-ignore
 // @ts-ignore Since dist/cjs/client/ is never used, we can ignore this error.
 const isProd = import.meta.env.PROD;
 assertSingleInstance_onClientEntryClientRouting(isProd);
+setVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry, true);
 initClientRouter();
 if (import.meta.env.DEV)
     removeFoucBuster();

package/dist/esm/client/runtime-client-routing/globalContext.d.ts

@@ -4,7 +4,7 @@ export type { GlobalContextClientInternal };
 import type { GlobalContextBasePublic } from '../../shared/createGlobalContextShared.js';
 type GlobalContextClient = GlobalContextBasePublic & Pick<GlobalContextClientInternal, 'isClientSide'> & Vike.GlobalContext & Vike.GlobalContextClient & {};
 type GlobalContextClientInternal = Awaited<ReturnType<typeof getGlobalContextClientInternal>>;
-declare const getGlobalContextClientInternal: () => Promise<{
+declare function getGlobalContextClientInternal(): Promise<{
     _globalConfigPublic: {
         pages: {
             [k: string]: {

package/dist/esm/client/runtime-client-routing/globalContext.js

@@ -1,9 +1,15 @@
+// TODO/now: rename file
+// TODO/now: rename export
 export { getGlobalContextClientInternal };
 import { createGetGlobalContextClient } from '../shared/createGetGlobalContextClient.js';
 import { loadPageRoutes } from '../../shared/route/loadPageRoutes.js';
-// @ts-ignore
-import * as virtualFileExportsGlobalEntry from 'virtual:vike:global-entry:client:client-routing';
-const getGlobalContextClientInternal = createGetGlobalContextClient(virtualFileExportsGlobalEntry, true, addGlobalContext);
+import { objectAssign } from './utils.js';
+async function getGlobalContextClientInternal() {
+    const globalContext = await createGetGlobalContextClient();
+    objectAssign(globalContext, await addGlobalContext(globalContext));
+    return globalContext;
+}
+// TO-DO/next-major-release make this function sync
 async function addGlobalContext(globalContext) {
     const { pageRoutes, onBeforeRouteHook } = await loadPageRoutes(globalContext._pageFilesAll, globalContext._pageConfigs, globalContext._pageConfigGlobal, globalContext._allPageIds);
     return {

package/dist/esm/client/runtime-client-routing/renderPageClientSide.d.ts

@@ -7,7 +7,7 @@ export type { PageContextBegin };
 import { type PageContextFromRewrite } from '../../shared/route/abort.js';
 import { type ScrollTarget } from './setScrollPosition.js';
 import type { PageContextConfig } from '../../shared/getPageFiles.js';
-import type { PageContextClient } from '../../types/PageContext.js';
+import type { PageContextClient, PageContextInternalClient } from '../../types/PageContext.js';
 import type { VikeGlobalInternal } from '../../types/VikeGlobalInternal.js';
 declare const firstRenderStartPromise: Promise<void>;
 type PageContextRouted = {
@@ -107,7 +107,7 @@ declare function getPageContextBegin(isForErrorPage: boolean, { urlOriginal, isB
     isHydration: boolean;
     previousPageContext: ({
         pageId: string;
-    } & PageContextConfig & PageContextRouted & import("../../shared/preparePageContextForPublicUsage.js").PageContextPrepareMinimum & import("../../types/PageContext.js").PageContextInternalClient & Omit<Partial<PageContextConfig & {
+    } & PageContextConfig & PageContextRouted & import("../../shared/preparePageContextForPublicUsage.js").PageContextPrepareMinimum & PageContextInternalClient & Omit<Partial<PageContextConfig & {
         isPageContext: true;
         Page: import("../../types/Config.js").Config["Page"];
         routeParams: Record<string, string>;

package/dist/esm/client/runtime-client-routing/renderPageClientSide.js

@@ -16,7 +16,7 @@ import { route } from '../../shared/route/index.js';
 import { isClientSideRoutable } from './isClientSideRoutable.js';
 import { setScrollPosition } from './setScrollPosition.js';
 import { scrollRestoration_initialRenderIsDone } from './scrollRestoration.js';
-import { getErrorPageId } from '../../shared/error-page.js';
+import { getErrorPageId, isErrorPage } from '../../shared/error-page.js';
 import { setPageContextCurrent } from './getPageContextCurrent.js';
 import { getRouteStringParameterList } from '../../shared/route/resolveRouteString.js';
 import { getCurrentUrl } from '../shared/getCurrentUrl.js';
@@ -644,3 +644,17 @@ function handleErrorFetchingStaticAssets(err, pageContext, isFirstRender) {
     redirectHard(pageContext.urlOriginal);
     return true;
 }
+// [HMR] If error page is shown => re-render whole page
+if (import.meta.env.DEV && import.meta.hot)
+    // TODO/now use after event
+    import.meta.hot.on('vite:beforeUpdate', () => {
+        const pageContext = globalObject.renderedPageContext;
+        if (pageContext?.pageId && isErrorPage(pageContext.pageId, pageContext._globalContext._pageConfigs)) {
+            renderPageClientSide({
+                scrollTarget: { preserveScroll: false },
+                urlOriginal: getCurrentUrl(),
+                overwriteLastHistoryEntry: true,
+                isBackwardNavigation: false,
+            });
+        }
+    });

package/dist/esm/client/runtime-server-routing/createPageContextClientSide.d.ts

@@ -54,7 +54,7 @@ declare function createPageContextClientSide(): Promise<{
         _allPageIds: string[];
     } & {
         isClientSide: true;
-    } & object;
+    };
     _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
     isBackwardNavigation: null;
     _hasPageContextFromServer: true;

package/dist/esm/client/runtime-server-routing/entry.js

@@ -6,9 +6,14 @@ import { assertSingleInstance_onClientEntryServerRouting } from './utils.js';
 import { removeFoucBuster } from '../shared/removeFoucBuster.js';
 import { execHook } from '../../shared/hooks/execHook.js';
 import { preparePageContextForPublicUsageClient } from './preparePageContextForPublicUsageClient.js';
+import { setVirtualFileExportsGlobalEntry } from '../shared/createGetGlobalContextClient.js';
+// @ts-expect-error
+import * as virtualFileExportsGlobalEntry from 'virtual:vike:global-entry:client:server-routing';
+// TODO/now: remove this ts-ignore
 // @ts-ignore Since dist/cjs/client/ is never used, we can ignore this error.
 const isProd = import.meta.env.PROD;
 assertSingleInstance_onClientEntryServerRouting(isProd);
+setVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry, false);
 if (import.meta.env.DEV)
     removeFoucBuster();
 hydrate();

package/dist/esm/client/runtime-server-routing/globalContext.d.ts

@@ -4,7 +4,7 @@ export type { GlobalContextClientInternalWithServerRouting };
 import type { GlobalContextBasePublic } from '../../shared/createGlobalContextShared.js';
 type GlobalContextClientWithServerRouting = GlobalContextBasePublic & Pick<GlobalContextClientInternalWithServerRouting, 'isClientSide'> & Vike.GlobalContext & Vike.GlobalContextClient & {};
 type GlobalContextClientInternalWithServerRouting = Awaited<ReturnType<typeof getGlobalContextClientInternal>>;
-declare const getGlobalContextClientInternal: () => Promise<{
+declare function getGlobalContextClientInternal(): Promise<{
     _globalConfigPublic: {
         pages: {
             [k: string]: {
@@ -52,4 +52,4 @@ declare const getGlobalContextClientInternal: () => Promise<{
     _allPageIds: string[];
 } & {
     isClientSide: true;
-} & object>;
+}>;

package/dist/esm/client/runtime-server-routing/globalContext.js

@@ -1,5 +1,9 @@
+// TODO/now: rename file
+// TODO/now: rename export
 export { getGlobalContextClientInternal };
 import { createGetGlobalContextClient } from '../shared/createGetGlobalContextClient.js';
-// @ts-ignore
-import * as virtualFileExportsGlobalEntry from 'virtual:vike:global-entry:client:server-routing';
-const getGlobalContextClientInternal = createGetGlobalContextClient(virtualFileExportsGlobalEntry, false);
+// TODO/now: remove this useless function and re-export instead?
+async function getGlobalContextClientInternal() {
+    const globalContext = await createGetGlobalContextClient();
+    return globalContext;
+}

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

@@ -1,11 +1,11 @@
 export { getGlobalContext };
 export { getGlobalContextSync };
+export { setVirtualFileExportsGlobalEntry };
 export { createGetGlobalContextClient };
 export type GlobalContextClientInternalShared = GlobalContextClientInternal | GlobalContextClientInternalWithServerRouting;
-import { type GlobalContextBase } from '../../shared/createGlobalContextShared.js';
 import type { GlobalContextClientInternal } from '../runtime-client-routing/globalContext.js';
 import type { GlobalContextClientInternalWithServerRouting } from '../runtime-server-routing/globalContext.js';
-declare function createGetGlobalContextClient<GlobalContextAddendum extends object>(virtualFileExportsGlobalEntry: unknown, isClientRouting: boolean, addGlobalContext?: (globalContext: GlobalContextBase) => Promise<GlobalContextAddendum>): () => Promise<{
+declare function createGetGlobalContextClient(): Promise<{
     _globalConfigPublic: {
         pages: {
             [k: string]: {
@@ -58,7 +58,8 @@ declare function createGetGlobalContextClient<GlobalContextAddendum extends obje
      * We recommend using `import.meta.env.SSR` instead, see https://vike.dev/globalContext
      */
     isClientSide: true;
-} & Awaited<GlobalContextAddendum>>;
+}>;
 type NeverExported = never;
 declare function getGlobalContext(): Promise<NeverExported>;
 declare function getGlobalContextSync(): NeverExported;
+declare function setVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry: unknown, isClientRouting: boolean): Promise<void>;

package/dist/esm/client/shared/createGetGlobalContextClient.js

@@ -1,7 +1,10 @@
 // Public usage
 export { getGlobalContext };
 export { getGlobalContextSync };
+export { setVirtualFileExportsGlobalEntry };
 // Internal usage
+// TODO/now rename export
+// TODO/now rename file
 export { createGetGlobalContextClient };
 import { createGlobalContextShared, getGlobalContextSyncErrMsg, } from '../../shared/createGlobalContextShared.js';
 import { getGlobalContextSerializedInHtml } from './getJsonSerializedInHtml.js';
@@ -13,42 +16,31 @@ const globalObject = getGlobalObject('createGetGlobalContextClient.ts', (() => {
         globalContextInitialPromiseResolve,
     };
 })());
-function createGetGlobalContextClient(virtualFileExportsGlobalEntry, isClientRouting, addGlobalContext) {
-    assert(globalObject.isClientRouting === undefined || globalObject.isClientRouting === isClientRouting);
-    globalObject.isClientRouting = isClientRouting;
-    // Eagerly call onCreateGlobalContext() hook
-    getGlobalContext();
-    return getGlobalContext;
-    async function getGlobalContext() {
-        // HMR => virtualFileExportsGlobalEntry differ
-        if (globalObject.virtualFileExportsGlobalEntry === virtualFileExportsGlobalEntry) {
-            const globalContext = await globalObject.globalContextPromise;
-            return globalContext;
-        }
-        else {
-            globalObject.virtualFileExportsGlobalEntry = virtualFileExportsGlobalEntry;
-        }
-        // Create
-        const globalContextPromise = createGlobalContextShared(virtualFileExportsGlobalEntry, globalObject, undefined, async (globalContext) => {
-            const globalContextAddendum = {
-                /**
-                 * Whether the environment is client-side or server-side / pre-rendering.
-                 *
-                 * We recommend using `import.meta.env.SSR` instead, see https://vike.dev/globalContext
-                 */
-                isClientSide: true,
-            };
-            objectAssign(globalContextAddendum, getGlobalContextSerializedInHtml());
-            objectAssign(globalContextAddendum, await addGlobalContext?.(globalContext));
-            return globalContextAddendum;
-        });
-        globalObject.globalContextPromise = globalContextPromise;
-        const globalContext = await globalContextPromise;
-        assert(globalObject.globalContext === globalContext);
-        globalObject.globalContextInitialPromiseResolve();
-        // Return
+async function createGetGlobalContextClient() {
+    if (globalObject.globalContextPromise) {
+        const globalContext = await globalObject.globalContextPromise;
         return globalContext;
     }
+    // Create
+    const globalContextPromise = createGlobalContextShared(globalObject.virtualFileExportsGlobalEntry, globalObject, undefined, async (globalContext) => {
+        const globalContextAddendum = {
+            // TODO/now update JSDocs
+            /**
+             * Whether the environment is client-side or server-side / pre-rendering.
+             *
+             * We recommend using `import.meta.env.SSR` instead, see https://vike.dev/globalContext
+             */
+            isClientSide: true,
+        };
+        objectAssign(globalContextAddendum, getGlobalContextSerializedInHtml());
+        return globalContextAddendum;
+    });
+    globalObject.globalContextPromise = globalContextPromise;
+    const globalContext = await globalContextPromise;
+    assert(globalObject.globalContext === globalContext);
+    globalObject.globalContextInitialPromiseResolve();
+    // Return
+    return globalContext;
 }
 async function getGlobalContext() {
     await globalObject.globalContextInitialPromise;
@@ -63,3 +55,15 @@ function getGlobalContextSync() {
     checkType(globalContext);
     return globalContext;
 }
+async function setVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry, isClientRouting) {
+    // TODO/now: remove unused globalObject.isClientRouting
+    assert(globalObject.isClientRouting === undefined || globalObject.isClientRouting === isClientRouting);
+    globalObject.isClientRouting = isClientRouting;
+    // HMR => virtualFileExportsGlobalEntry differ
+    if (globalObject.virtualFileExportsGlobalEntry !== virtualFileExportsGlobalEntry) {
+        delete globalObject.globalContextPromise;
+        globalObject.virtualFileExportsGlobalEntry = virtualFileExportsGlobalEntry;
+        // Eagerly call +onCreateGlobalContext() hooks
+        await createGetGlobalContextClient();
+    }
+}

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

@@ -4,8 +4,10 @@ export { plugin };
 export { plugin as ssr };
 export { getVikeConfig } from './shared/resolveVikeConfigInternal.js';
 export { PROJECT_VERSION as version } from './utils.js';
+import { getClientEntrySrcDev } from './shared/getClientEntrySrcDev.js';
+import { setGetClientEntrySrcDev } from '../runtime/renderPage/getPageAssets/retrievePageAssetsDev.js';
 import { assertUsage } from './utils.js';
-import { pluginBuild } from './plugins/pluginBuild.js';
+import pc from '@brillout/picocolors';
 import { pluginPreview } from './plugins/pluginPreview.js';
 import { pluginDev } from './plugins/pluginDev.js';
 import { pluginVirtualFiles } from './plugins/pluginVirtualFiles.js';
@@ -15,38 +17,55 @@ import { pluginSetGlobalContext } from './plugins/pluginSetGlobalContext.js';
 import { pluginCommon } from './plugins/pluginCommon.js';
 import { pluginBaseUrls } from './plugins/pluginBaseUrls.js';
 import { pluginEnvVars } from './plugins/pluginEnvVars.js';
-import pc from '@brillout/picocolors';
 import { pluginFileEnv } from './plugins/pluginFileEnv.js';
-import { getClientEntrySrcDev } from './shared/getClientEntrySrcDev.js';
 import { pluginWorkaroundCssModuleHmr } from './plugins/pluginWorkaroundCssModuleHmr.js';
 import { pluginWorkaroundVite6HmrRegression } from './plugins/pluginWorkaroundVite6HmrRegression.js';
-import { pluginReplaceConstants } from './plugins/pluginReplaceConstants.js';
+import { pluginReplaceIsClientSide } from './plugins/pluginReplaceIsClientSide.js';
+import { pluginReplaceGlobalThisConstants } from './plugins/pluginReplaceGlobalThisConstants.js';
 import { pluginNonRunnableDev } from './plugins/pluginNonRunnableDev.js';
-import { setGetClientEntrySrcDev } from '../runtime/renderPage/getPageAssets/retrievePageAssetsDev.js';
+import { pluginBuildApp } from './plugins/pluginBuild/pluginBuildApp.js';
+import { pluginDistPackageJsonFile } from './plugins/pluginBuild/pluginDistPackageJsonFile.js';
+import { pluginSuppressRollupWarning } from './plugins/pluginBuild/pluginSuppressRollupWarning.js';
+import { pluginDistFileNames } from './plugins/pluginBuild/pluginDistFileNames.js';
+import { pluginProdBuildEntry } from './plugins/pluginBuild/pluginProdBuildEntry.js';
+import { pluginBuildConfig } from './plugins/pluginBuild/pluginBuildConfig.js';
+import { pluginModuleBanner } from './plugins/pluginBuild/pluginModuleBanner.js';
 // We don't call this in ./onLoad.ts to avoid a cyclic dependency with utils.ts
 setGetClientEntrySrcDev(getClientEntrySrcDev);
 // Return `PluginInterop` instead of `Plugin` to avoid type mismatch upon different Vite versions
 function plugin(vikeVitePluginOptions = {}) {
     const plugins = [
         ...pluginCommon(vikeVitePluginOptions),
-        pluginVirtualFiles(),
+        ...pluginVirtualFiles(),
         ...pluginDev(),
         ...pluginBuild(),
-        pluginPreview(),
+        ...pluginPreview(),
         ...pluginExtractAssets(),
-        pluginExtractExportNames(),
+        ...pluginExtractExportNames(),
         ...pluginSetGlobalContext(),
-        pluginBaseUrls(),
-        pluginEnvVars(),
-        pluginFileEnv(),
-        pluginWorkaroundCssModuleHmr(),
-        pluginWorkaroundVite6HmrRegression(),
-        pluginReplaceConstants(),
-        pluginNonRunnableDev(),
+        ...pluginBaseUrls(),
+        ...pluginEnvVars(),
+        ...pluginFileEnv(),
+        ...pluginWorkaroundCssModuleHmr(),
+        ...pluginWorkaroundVite6HmrRegression(),
+        ...pluginReplaceIsClientSide(),
+        ...pluginReplaceGlobalThisConstants(),
+        ...pluginNonRunnableDev(),
     ];
     Object.assign(plugins, { _vikeVitePluginOptions: vikeVitePluginOptions });
     return plugins;
 }
+function pluginBuild() {
+    return [
+        ...pluginBuildConfig(),
+        ...pluginBuildApp(),
+        ...pluginProdBuildEntry(),
+        ...pluginDistPackageJsonFile(),
+        ...pluginSuppressRollupWarning(),
+        ...pluginDistFileNames(),
+        ...pluginModuleBanner(),
+    ];
+}
 // Error upon wrong usage
 Object.defineProperty(plugin, 'apply', {
     enumerable: true,

package/dist/esm/node/vite/plugins/pluginBaseUrls.d.ts

@@ -1,3 +1,3 @@
 export { pluginBaseUrls };
 import type { Plugin } from 'vite';
-declare function pluginBaseUrls(): Plugin;
+declare function pluginBaseUrls(): Plugin[];

package/dist/esm/node/vite/plugins/pluginBaseUrls.js

@@ -4,44 +4,46 @@ import { assert } from '../utils.js';
 import { getVikeConfigInternal } from '../shared/resolveVikeConfigInternal.js';
 function pluginBaseUrls() {
     let basesResolved;
-    return {
-        name: 'vike:pluginBaseUrls',
-        enforce: 'post',
-        config: {
-            async handler(config) {
-                const isDev = config._isDev;
-                assert(typeof isDev === 'boolean');
-                const baseViteOriginal = config.base ?? '/__UNSET__'; // '/__UNSET__' because Vite resolves `_baseViteOriginal: null` to `undefined`
-                const vikeConfig = await getVikeConfigInternal();
-                basesResolved = resolveBase(baseViteOriginal, vikeConfig.config.baseServer ?? null, vikeConfig.config.baseAssets ?? null);
-                // We cannot define these in configResolved() because Vite picks up the env variables before any configResolved() hook is called
-                process.env.BASE_SERVER = basesResolved.baseServer;
-                process.env.BASE_ASSETS = basesResolved.baseAssets;
-                return {
-                    envPrefix: [
-                        'VITE_', // Vite doesn't seem to merge in its default, see https://github.com/vikejs/vike/issues/554
-                        'BASE_SERVER',
-                        'BASE_ASSETS',
-                    ],
-                    base: basesResolved.baseAssets, // Make Vite inject baseAssets to imports e.g. `import logoUrl from './logo.svg.js'`
-                    _baseViteOriginal: baseViteOriginal,
-                };
+    return [
+        {
+            name: 'vike:pluginBaseUrls',
+            enforce: 'post',
+            config: {
+                async handler(config) {
+                    const isDev = config._isDev;
+                    assert(typeof isDev === 'boolean');
+                    const baseViteOriginal = config.base ?? '/__UNSET__'; // '/__UNSET__' because Vite resolves `_baseViteOriginal: null` to `undefined`
+                    const vikeConfig = await getVikeConfigInternal();
+                    basesResolved = resolveBase(baseViteOriginal, vikeConfig.config.baseServer ?? null, vikeConfig.config.baseAssets ?? null);
+                    // We cannot define these in configResolved() because Vite picks up the env variables before any configResolved() hook is called
+                    process.env.BASE_SERVER = basesResolved.baseServer;
+                    process.env.BASE_ASSETS = basesResolved.baseAssets;
+                    return {
+                        envPrefix: [
+                            'VITE_', // Vite doesn't seem to merge in its default, see https://github.com/vikejs/vike/issues/554
+                            'BASE_SERVER',
+                            'BASE_ASSETS',
+                        ],
+                        base: basesResolved.baseAssets, // Make Vite inject baseAssets to imports e.g. `import logoUrl from './logo.svg.js'`
+                        _baseViteOriginal: baseViteOriginal,
+                    };
+                },
             },
-        },
-        configResolved: {
-            async handler(config) {
-                const vikeConfig = await getVikeConfigInternal();
-                const basesResolved2 = resolveBaseFromResolvedConfig(vikeConfig.config.baseServer ?? null, vikeConfig.config.baseAssets ?? null, config);
-                assert(basesResolved2.baseServer === basesResolved.baseServer);
-                assert(basesResolved2.baseAssets === basesResolved.baseAssets);
-                /* In dev, Vite seems buggy around setting vite.config.js#base to an absolute URL (e.g. http://localhost:8080/cdn/)
-               *  - In dev, Vite removes the URL origin. (I.e. it resolves the user config `vite.config.js#base: 'http://localhost:8080/cdn/'` to resolved config `config.base === '/cdn/'`.)
-               *  - Instead of having an internal Vike assertion fail, we let the user discover Vite's buggy behavior.
-              assert(config.base === baseAssets)
-              */
+            configResolved: {
+                async handler(config) {
+                    const vikeConfig = await getVikeConfigInternal();
+                    const basesResolved2 = resolveBaseFromResolvedConfig(vikeConfig.config.baseServer ?? null, vikeConfig.config.baseAssets ?? null, config);
+                    assert(basesResolved2.baseServer === basesResolved.baseServer);
+                    assert(basesResolved2.baseAssets === basesResolved.baseAssets);
+                    /* In dev, Vite seems buggy around setting vite.config.js#base to an absolute URL (e.g. http://localhost:8080/cdn/)
+                 *  - In dev, Vite removes the URL origin. (I.e. it resolves the user config `vite.config.js#base: 'http://localhost:8080/cdn/'` to resolved config `config.base === '/cdn/'`.)
+                 *  - Instead of having an internal Vike assertion fail, we let the user discover Vite's buggy behavior.
+                assert(config.base === baseAssets)
+                */
+                },
             },
         },
-    };
+    ];
 }
 function resolveBaseFromResolvedConfig(baseServer, baseAssets, config) {
     let baseViteOriginal = config._baseViteOriginal;

package/dist/esm/node/vite/plugins/pluginBuild/handleAssetsManifest.d.ts

@@ -3,10 +3,14 @@ export { handleAssetsManifest_getBuildConfig };
 export { handleAssetsManifest_isFixEnabled };
 export { handleAssetsManifest_assertUsageCssCodeSplit };
 export { handleAssetsManifest_assertUsageCssTarget };
+export { handleAssetsManifest_workaroundCssTarget_part1 };
+export { handleAssetsManifest_workaroundCssTarget_part2 };
 import type { Environment, ResolvedConfig, Rollup } from 'vite';
 type Bundle = Rollup.OutputBundle;
 declare function handleAssetsManifest_isFixEnabled(): boolean;
 declare function handleAssetsManifest_assertUsageCssCodeSplit(config: ResolvedConfig): void;
+declare function handleAssetsManifest_workaroundCssTarget_part1(config: ResolvedConfig): void;
+declare function handleAssetsManifest_workaroundCssTarget_part2(): void;
 declare function handleAssetsManifest_assertUsageCssTarget(config: ResolvedConfig, env: Environment): void;
 declare function handleAssetsManifest_getBuildConfig(): Promise<{
     readonly ssrEmitAssets: true | undefined;

package/dist/esm/node/vite/plugins/pluginBuild/handleAssetsManifest.js

@@ -3,6 +3,8 @@ export { handleAssetsManifest_getBuildConfig };
 export { handleAssetsManifest_isFixEnabled };
 export { handleAssetsManifest_assertUsageCssCodeSplit };
 export { handleAssetsManifest_assertUsageCssTarget };
+export { handleAssetsManifest_workaroundCssTarget_part1 };
+export { handleAssetsManifest_workaroundCssTarget_part2 };
 import fs from 'node:fs/promises';
 import fs_sync from 'node:fs';
 import path from 'node:path';
@@ -13,11 +15,14 @@ import { getAssetsDir } from '../../shared/getAssetsDir.js';
 import pc from '@brillout/picocolors';
 import { isV1Design } from '../../shared/resolveVikeConfigInternal.js';
 import { getOutDirs } from '../../shared/getOutDirs.js';
-import { isViteServerSide_onlySsrEnv, isViteServerSide } from '../../shared/isViteServerSide.js';
+import { isViteServerSide_onlySsrEnv, isViteServerSide, isViteServerSide_viteEnvOptional, } from '../../shared/isViteServerSide.js';
 import { set_macro_ASSETS_MANIFEST } from './pluginProdBuildEntry.js';
 import { getManifestFilePathRelative } from '../../shared/getManifestFilePathRelative.js';
-const globalObject = getGlobalObject('build/handleAssetsManifest.ts', {
+const globalObject = getGlobalObject('handleAssetsManifest.ts', {
     assetsJsonFilePath: undefined,
+    cssTarget: '__VIKE__UNSET',
+    targetsAll: [],
+    configsAll: [],
 });
 // yes  => use workaround config.build.ssrEmitAssets
 // false => use workaround extractAssets plugin
@@ -216,16 +221,26 @@ function handleAssetsManifest_assertUsageCssCodeSplit(config) {
         return;
     assertWarning(config.build.cssCodeSplit, `${pc.cyan('build.cssCodeSplit')} shouldn't be set to ${pc.cyan('false')} (https://github.com/vikejs/vike/issues/1993)`, { onlyOnce: true });
 }
-const targets = [];
+function handleAssetsManifest_workaroundCssTarget_part1(config) {
+    globalObject.configsAll.push(config);
+    if (!isViteServerSide_viteEnvOptional(config, undefined)) {
+        globalObject.cssTarget = config.build.cssTarget;
+    }
+}
+function handleAssetsManifest_workaroundCssTarget_part2() {
+    assert(globalObject.cssTarget !== '__VIKE__UNSET');
+    globalObject.configsAll.forEach((c) => (c.build.cssTarget = globalObject.cssTarget));
+}
 function handleAssetsManifest_assertUsageCssTarget(config, env) {
     if (!handleAssetsManifest_isFixEnabled())
         return;
     const isServerSide = isViteServerSide(config, env);
     assert(typeof isServerSide === 'boolean');
     assert(config.build.target !== undefined);
-    targets.push({ global: config.build.target, css: config.build.cssTarget, isServerSide });
-    const targetsServer = targets.filter((t) => t.isServerSide);
-    const targetsClient = targets.filter((t) => !t.isServerSide);
+    const { targetsAll } = globalObject;
+    targetsAll.push({ global: config.build.target, css: config.build.cssTarget, isServerSide });
+    const targetsServer = targetsAll.filter((t) => t.isServerSide);
+    const targetsClient = targetsAll.filter((t) => !t.isServerSide);
     targetsClient.forEach((targetClient) => {
         const targetCssResolvedClient = resolveCssTarget(targetClient);
         targetsServer.forEach((targetServer) => {

package/dist/esm/node/vite/plugins/pluginBuild/pluginBuildConfig.js

@@ -10,20 +10,32 @@ import { prependEntriesDir } from '../../../shared/prependEntriesDir.js';
 import { getFilePathResolved } from '../../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../../shared/page-configs/getConfigValueBuildTime.js';
 import { isViteServerSide_viteEnvOptional } from '../../shared/isViteServerSide.js';
-import { handleAssetsManifest_assertUsageCssCodeSplit, handleAssetsManifest_getBuildConfig, } from './handleAssetsManifest.js';
+import { handleAssetsManifest_assertUsageCssCodeSplit, handleAssetsManifest_getBuildConfig, handleAssetsManifest_workaroundCssTarget_part1, handleAssetsManifest_workaroundCssTarget_part2, } from './handleAssetsManifest.js';
 import { resolveIncludeAssetsImportedByServer } from '../../../runtime/renderPage/getPageAssets/retrievePageAssetsProd.js';
 function pluginBuildConfig() {
     let config;
     return [
         {
-            name: 'vike:build:pluginBuildConfig',
+            name: 'vike:build:pluginBuildConfig:post1',
             apply: 'build',
             enforce: 'post',
             configResolved: {
                 order: 'post',
-                async handler(config_) {
-                    onSetupBuild();
+                handler(config_) {
                     config = config_;
+                    handleAssetsManifest_workaroundCssTarget_part1(config);
+                },
+            },
+        },
+        {
+            name: 'vike:build:pluginBuildConfig:post2',
+            apply: 'build',
+            enforce: 'post',
+            configResolved: {
+                order: 'post',
+                async handler() {
+                    handleAssetsManifest_workaroundCssTarget_part2();
+                    onSetupBuild();
                     assertRollupInput(config);
                     const entries = await getEntries(config);
                     assert(Object.keys(entries).length > 0);

package/dist/esm/node/vite/plugins/pluginBuild/pluginDistFileNames.d.ts

@@ -1,3 +1,3 @@
 export { pluginDistFileNames };
 import type { Plugin } from 'vite';
-declare function pluginDistFileNames(): Plugin;
+declare function pluginDistFileNames(): Plugin[];