vike 0.4.266 → 0.4.267

package/dist/client/runtime-client-routing/history.d.ts

@@ -1,11 +1,28 @@
-export { pushHistoryState };
-export { replaceHistoryStateOriginal };
+export { changeUrl };
 export { onPopStateBegin };
 export { saveScrollPosition };
 export { initHistory };
+export { historyApiReplaceStateOriginal };
 export type { HistoryInfo };
 export type { ScrollPosition };
 import '../assertEnvClient.js';
+declare function changeUrl(url: string, overwriteLastHistoryEntry: boolean): void;
+declare function historyApiReplaceStateOriginal(state: unknown, url?: Parameters<typeof window.history.replaceState>[2]): void;
+declare function onPopStateBegin(): {
+    skip: true;
+    previous?: undefined;
+    current?: undefined;
+} | {
+    skip?: undefined;
+    previous: HistoryInfo;
+    current: HistoryInfo;
+};
+type ScrollPosition = {
+    x: number;
+    y: number;
+};
+declare function saveScrollPosition(scrollPosition?: ScrollPosition): void;
+declare function initHistory(): void;
 type StateEnhanced = {
     vike: {
         timestamp: number;
@@ -13,24 +30,7 @@ type StateEnhanced = {
         triggeredBy: 'user' | 'vike' | 'browser';
     };
 };
-type ScrollPosition = {
-    x: number;
-    y: number;
-};
-declare function saveScrollPosition(scrollPosition?: ScrollPosition): void;
-declare function pushHistoryState(url: string, overwriteLastHistoryEntry: boolean): void;
-declare function replaceHistoryStateOriginal(state: unknown, url?: Parameters<typeof window.history.replaceState>[2]): void;
 type HistoryInfo = {
     url: `/${string}`;
     state: StateEnhanced;
 };
-declare function onPopStateBegin(): {
-    skip: true;
-    previous?: undefined;
-    current?: undefined;
-} | {
-    skip?: undefined;
-    previous: HistoryInfo;
-    current: HistoryInfo;
-};
-declare function initHistory(): void;

package/dist/client/runtime-client-routing/history.js

@@ -1,8 +1,8 @@
-export { pushHistoryState };
-export { replaceHistoryStateOriginal };
+export { changeUrl };
 export { onPopStateBegin };
 export { saveScrollPosition };
 export { initHistory };
+export { historyApiReplaceStateOriginal };
 import { getCurrentUrl } from '../shared/getCurrentUrl.js';
 import { assert, assertUsage } from '../../utils/assert.js';
 import { getGlobalObject } from '../../utils/getGlobalObject.js';
@@ -15,49 +15,9 @@ const globalObject = getGlobalObject('history.ts', {
 });
 initHistory(); // we redundantly call initHistory() to ensure it's called early
 globalObject.previous = getHistoryInfo();
-// `window.history.state === null` when:
-// - The very first render
-// - Click on `<a href="#some-hash" />`
-// - `location.hash = 'some-hash'`
-function enhance() {
-    if (isEnhanced(window.history.state))
-        return;
-    const stateEnhanced = {
-        vike: {
-            timestamp: getTimestamp(),
-            scrollPosition: getScrollPosition(),
-            triggeredBy: 'browser',
-        },
-    };
-    replaceHistoryState(stateEnhanced);
-}
-function getState() {
-    const state = window.history.state;
-    // *Every* state added to the history needs to go through Vike.
-    // - Otherwise Vike's `popstate` listener won't work. (Because, for example, if globalObject.previous is outdated => isHashNavigation faulty => client-side navigation is wrongfully skipped.)
-    // - Therefore, we have to monkey patch history.pushState() and history.replaceState()
-    // - Therefore, we need the assert() below to ensure history.state has been enhanced by Vike
-    //   - If users stumble upon this assert() then let's make it a assertUsage()
-    assertIsEnhanced(state);
-    return state;
-}
-function getScrollPosition() {
-    const scrollPosition = { x: window.scrollX, y: window.scrollY };
-    return scrollPosition;
-}
-function getTimestamp() {
-    return new Date().getTime();
-}
-function saveScrollPosition(scrollPosition) {
-    scrollPosition || (scrollPosition = getScrollPosition());
-    // Don't overwrite history.state if it was set by a non-Vike history.pushState() call.
-    // https://github.com/vikejs/vike/issues/2801#issuecomment-3490431479
-    if (!isEnhanced(window.history.state))
+function changeUrl(url, overwriteLastHistoryEntry) {
+    if (getCurrentUrl() === url)
         return;
-    const state = getState();
-    replaceHistoryState({ ...state, vike: { ...state.vike, scrollPosition } });
-}
-function pushHistoryState(url, overwriteLastHistoryEntry) {
     if (!overwriteLastHistoryEntry) {
         const state = {
             vike: {
@@ -67,24 +27,68 @@ function pushHistoryState(url, overwriteLastHistoryEntry) {
                 triggeredBy: 'vike',
             },
         };
-        // Calling the monkey patched history.pushState() (and not the original) so that other tools (e.g. user tracking) can listen to Vike's pushState() calls.
-        // - https://github.com/vikejs/vike/issues/1582
-        window.history.pushState(state, '', url);
+        historyApiPushState(state, url);
     }
     else {
-        replaceHistoryState(getState(), url);
+        historyApiReplaceState(getState(), url);
     }
 }
-function replaceHistoryState(state, url) {
+function historyApiPushState(state, url) {
+    // Calling the monkey patched history.pushState() (not the original) so that other tools (e.g. user tracking) can listen to Vike's pushState() calls.
+    // - https://github.com/vikejs/vike/issues/1582
+    window.history.pushState(state, '', url);
+    assertIsEnhanced(window.history.state);
+}
+function historyApiReplaceState(state, url) {
     const url_ = url ?? null; // Passing `undefined` chokes older Edge versions.
     window.history.replaceState(state, '', url_);
     assertIsEnhanced(window.history.state);
 }
-function replaceHistoryStateOriginal(state, url) {
+function historyApiReplaceStateOriginal(state, url) {
     // Bypass all monkey patches.
     // - Useful, for example, to avoid other tools listening to history.replaceState() calls
     History.prototype.replaceState.bind(window.history)(state, '', url);
 }
+function onPopStateBegin() {
+    const { previous } = globalObject;
+    const isStateEnhanced = isEnhanced(window.history.state);
+    // Either:
+    // - `window.history.pushState(null, '', '/some-path')` , or
+    // - hash navigation
+    //   - Click on `<a href="#some-hash">`
+    //   - Using the `location` API (only hash navigation)
+    // See comments a the top of the ./initOnPopState.ts file.
+    const isStatePristine = window.history.state === null;
+    if (!isStateEnhanced && !isStatePristine) {
+        // Going to a history entry not created by Vike — entering another "SPA realm" => hard reload
+        // https://github.com/vikejs/vike/issues/2801#issuecomment-3490431479
+        redirectHard(getCurrentUrl());
+        return { skip: true };
+    }
+    if (!isStateEnhanced)
+        enhanceState();
+    const current = getHistoryInfo();
+    globalObject.previous = current;
+    // Let the browser handle hash navigations.
+    // - Upon hash navigation: `isHistoryStatePristine===true` (see comment above).
+    if (isStatePristine) {
+        return { skip: true };
+    }
+    return { previous, current };
+}
+function saveScrollPosition(scrollPosition) {
+    scrollPosition || (scrollPosition = getScrollPosition());
+    // Don't overwrite history.state if it was set by a non-Vike history.pushState() call.
+    // https://github.com/vikejs/vike/issues/2801#issuecomment-3490431479
+    if (!isEnhanced(window.history.state))
+        return;
+    const state = getState();
+    historyApiReplaceState({ ...state, vike: { ...state.vike, scrollPosition } });
+}
+function initHistory() {
+    monkeyPatchHistoryAPI(); // the earlier we call it the better (Vike can workaround erroneous library monkey patches if Vike is the last one in the monkey patch chain)
+    enhanceState(); // enhance very first window.history.state which is `null`
+}
 // Monkey patch:
 // - history.pushState()
 // - history.replaceState()
@@ -114,11 +118,26 @@ function monkeyPatchHistoryAPI() {
                 if (isEnhanced(window.history.state))
                     return;
                 Object.assign(state, window.history.state);
-                replaceHistoryStateOriginal(state);
+                historyApiReplaceStateOriginal(state);
             });
         };
     });
 }
+function getState() {
+    const state = window.history.state;
+    // *Every* state added to the history needs to go through Vike.
+    // - Otherwise Vike's `popstate` listener won't work. (Because, for example, if globalObject.previous is outdated => isHashNavigation faulty => client-side navigation is wrongfully skipped.)
+    // - Therefore, we have to monkey patch history.pushState() and history.replaceState()
+    // - Therefore, we need the assert() below to ensure history.state has been enhanced by Vike
+    //   - If users stumble upon this assert() then let's make it a assertUsage()
+    assertIsEnhanced(state);
+    return state;
+}
+function assertIsEnhanced(state) {
+    if (isEnhanced(state))
+        return;
+    assert(false, { state });
+}
 function isEnhanced(state) {
     if (state?.vike) {
         /* We don't use the assert() below to save client-side KBs.
@@ -135,10 +154,21 @@ function isEnhanced(state) {
     }
     return false;
 }
-function assertIsEnhanced(state) {
-    if (isEnhanced(state))
+// `window.history.state === null` when:
+// - The very first render
+// - Click on `<a href="#some-hash" />`
+// - `location.hash = 'some-hash'`
+function enhanceState() {
+    if (isEnhanced(window.history.state))
         return;
-    assert(false, { state });
+    const stateEnhanced = {
+        vike: {
+            timestamp: getTimestamp(),
+            scrollPosition: getScrollPosition(),
+            triggeredBy: 'browser',
+        },
+    };
+    historyApiReplaceState(stateEnhanced);
 }
 function getHistoryInfo() {
     return {
@@ -146,34 +176,10 @@ function getHistoryInfo() {
         state: getState(),
     };
 }
-function onPopStateBegin() {
-    const { previous } = globalObject;
-    const isStateEnhanced = isEnhanced(window.history.state);
-    // Either:
-    // - `window.history.pushState(null, '', '/some-path')` , or
-    // - hash navigation
-    //   - Click on `<a href="#some-hash">`
-    //   - Using the `location` API (only hash navigation)
-    // See comments a the top of the ./initOnPopState.ts file.
-    const isStatePristine = window.history.state === null;
-    if (!isStateEnhanced && !isStatePristine) {
-        // Going to a history entry not created by Vike — entering another "SPA realm" => hard reload
-        // https://github.com/vikejs/vike/issues/2801#issuecomment-3490431479
-        redirectHard(getCurrentUrl());
-        return { skip: true };
-    }
-    if (!isStateEnhanced)
-        enhance();
-    const current = getHistoryInfo();
-    globalObject.previous = current;
-    // Let the browser handle hash navigations.
-    // - Upon hash navigation: `isHistoryStatePristine===true` (see comment above).
-    if (isStatePristine) {
-        return { skip: true };
-    }
-    return { previous, current };
+function getScrollPosition() {
+    const scrollPosition = { x: window.scrollX, y: window.scrollY };
+    return scrollPosition;
 }
-function initHistory() {
-    monkeyPatchHistoryAPI(); // the earlier we call it the better (Vike can workaround erroneous library monkey patches if Vike is the last one in the monkey patch chain)
-    enhance(); // enhance very first window.history.state which is `null`
+function getTimestamp() {
+    return new Date().getTime();
 }

package/dist/client/runtime-client-routing/renderPageClient.js

@@ -17,7 +17,7 @@ import { createPageContextClient } from './createPageContextClient.js';
 import { addLinkPrefetchHandlers, addLinkPrefetchHandlers_unwatch, addLinkPrefetchHandlers_watch, getPageContextPrefetched, populatePageContextPrefetchCache, } from './prefetch.js';
 import { execHookOnRenderClient } from '../shared/execHookOnRenderClient.js';
 import { isErrorFetchingStaticAssets, loadPageConfigsLazyClientSide, } from '../shared/loadPageConfigsLazyClientSide.js';
-import { pushHistoryState, saveScrollPosition } from './history.js';
+import { changeUrl, saveScrollPosition } from './history.js';
 import { addNewPageContextAborted, getPageContextAddendumAbort, isAbortError, logAbort, } from '../../shared-server-client/route/abort.js';
 import { route } from '../../shared-server-client/route/index.js';
 import { isClientSideRoutable } from './isClientSideRoutable.js';
@@ -527,11 +527,6 @@ function stampFinished(urlOriginal) {
     window._vike ?? (window._vike = {});
     window._vike.fullyRenderedUrl = urlOriginal;
 }
-function changeUrl(url, overwriteLastHistoryEntry) {
-    if (getCurrentUrl() === url)
-        return;
-    pushHistoryState(url, overwriteLastHistoryEntry);
-}
 function disableClientRouting(err, log) {
     globalObject.clientRoutingIsDisabled = true;
     assert(isErrorFetchingStaticAssets(err));

package/dist/client/runtime-client-routing/setScrollPosition.js

@@ -6,7 +6,7 @@ import { assert } from '../../utils/assert.js';
 import { onPageHide } from '../../utils/onPageVisibilityChange.js';
 import { sleep } from '../../utils/sleep.js';
 import { throttle } from '../../utils/throttle.js';
-import { replaceHistoryStateOriginal, saveScrollPosition } from './history.js';
+import { historyApiReplaceStateOriginal, saveScrollPosition } from './history.js';
 import '../assertEnvClient.js';
 function setScrollPosition(scrollTarget, url) {
     if (!scrollTarget && url && hasTextFragment(url)) {
@@ -23,17 +23,18 @@ function setScrollPosition(scrollTarget, url) {
     const hash = getUrlHash();
     scrollToHashOrTop(hash);
 }
-// https://github.com/vikejs/vike/issues/2114
-// https://github.com/WICG/scroll-to-text-fragment/issues/261
+// Scroll to the DOM element the URL fragment points to, using window.locale.replace()
+// - https://github.com/vikejs/vike/issues/2114
+// - https://github.com/WICG/scroll-to-text-fragment/issues/261
 function scrollToTextFragment(url) {
     const stateOriginal = window.history.state;
-    replaceHistoryStateOriginal(null, url);
+    historyApiReplaceStateOriginal(null, url);
     // We need `history.state===null` before location.replace() so that our 'popstate' handling is correct
     assert(window.history.state === null);
     // - Chrome's location.replace() keeps the current state (`history.state===stateOriginal`)
     // - Firefox's location.replace() replaces the current state with `null` (`history.state===null`)
     window.location.replace(url);
-    replaceHistoryStateOriginal(stateOriginal, url);
+    historyApiReplaceStateOriginal(stateOriginal, url);
 }
 function hasTextFragment(url) {
     return url.includes('#') && url.includes(':~:text');

package/dist/node/prerender/runPrerender.js

@@ -124,6 +124,17 @@ async function runPrerender(options = {}, trigger) {
     if (logLevel === 'info') {
         console.log(`${pc.green(`✓`)} ${prerenderedCount} HTML documents pre-rendered.`);
     }
+    const { precompress } = vikeConfig.config;
+    if (precompress &&
+        // During `$ vike build` (`auto-run`), the build's own precompress pass covers these files.
+        trigger !== 'auto-run' &&
+        // `onPagePrerender` setting defined => no `.html`/`.json` files written => we also don't write `.br`/`.gz` files
+        !options.onPagePrerender) {
+        const { precompressFiles } = await import('@universal-deploy/vite');
+        const { written } = await precompressFiles(prerenderContext.output.map((o) => o.filePath), precompress);
+        if (written > 0)
+            console.log(`${pc.green(`✓`)} ${written} precompressed files.`);
+    }
     await warnMissingPages(prerenderContext._prerenderedPageContexts, globalContext, doNotPrerenderList, partial);
     const prerenderContextPublic = getPrerenderContextPublic(prerenderContext);
     objectAssign(vikeConfig.prerenderContext, prerenderContextPublic, true);

package/dist/node/vite/assertEnvVite.js

@@ -12,7 +12,7 @@ function assertEnvVite() {
     assertIsNotBrowser();
     assertNodeVersion();
     assertViteVersion(viteVersion);
-    assertIsNotProductionRuntime(); // Don't bloat server with heavy dependencies like Vite and esbuild
+    assertIsNotProductionRuntime(); // Don't bloat server with heavy dependencies like Vite
 }
 function onLoad() {
     installUncaughtErrorHandlers();

package/dist/node/vite/plugins/build/handleAssetsManifest.js

@@ -310,7 +310,8 @@ async function handleAssetsManifest_getBuildConfig(config) {
         if (config.build?.cssMinify === undefined)
             build.cssMinify = isVite8OrAbove(config) ? true : 'esbuild';
     }
-    if (config.build?.manifest === undefined)
+    assertWarning(config.build?.manifest !== false, `Setting Vite's configuration ${pc.cyan('build.manifest')} to ${pc.cyan('false')} is ignored — Vike overrides it to ${pc.cyan('true')} because Vike needs the manifest. Note that Vike removes the manifest from the client-side bundle, see ${pc.underline('https://github.com/vikejs/vike/issues/3505#issuecomment-5563748527')}`, { onlyOnce: true });
+    if (config.build?.manifest === undefined || config.build?.manifest === false)
         build.manifest = true;
     /* Already set by vike:build:pluginBuildApp
     if (config.build?.copyPublicDir === undefined) build.copyPublicDir = !isViteServerSide_viteEnvOptional(config)

package/dist/node/vite/plugins/pluginDev/logSkillHint.js

@@ -15,6 +15,7 @@ import { requireResolveOptional } from '../../../../utils/requireResolve.js';
 import { setTimeoutUnref } from '../../../../utils/setTimeoutUnref.js';
 import { isObject } from '../../../../utils/isObject.js';
 import { toPosixPath } from '../../../../utils/path.js';
+import { PROJECT_VERSION } from '../../../../utils/PROJECT_VERSION.js';
 import { unique } from '../../../../utils/unique.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 import { getCacheValue, setCacheValue } from '../../shared/cache.js';
@@ -37,7 +38,7 @@ const skillName = 'vike';
 // The skill file shipped by the vike npm package: node_modules/vike/skills/vike/SKILL.md (see packages/vike/scripts/copySkill.mjs)
 const skillFilePathInsidePackage = 'skills/vike/SKILL.md';
 // Cache entry at node_modules/.vike/cache.json, see cache.ts
-// - `false` => the check didn't log anything last time => skip the check (forever, until node_modules/ is removed)
+// - `{ skip: true, version }` => the check didn't log anything last time, with that Vike version => skip the check until Vike is upgraded (the official skill file may change between Vike versions) or node_modules/ is removed
 // - Nothing is written as long as the hint is logged => the check is re-run upon every dev start
 const cacheKey = 'logSkillHint';
 // Log a hint if the user didn't install Vike's skill for AI agents (vike/SKILL.md), or if it differs from the official one — https://vike.dev/ai#skill
@@ -95,8 +96,9 @@ async function checkSkillUnsafe(userRootDir) {
     if (!getConfigValueAiSkill(vikeConfig))
         return;
     globalObject.alreadyChecked = true;
-    // The check is skipped forever once it didn't log anything (until node_modules/ is removed) — see cacheKey
-    if ((await getCacheValue(userRootDir, cacheKey)) === false)
+    // The check is skipped once it didn't log anything, until Vike is upgraded (or node_modules/ is removed) — see cacheKey
+    const cached = await getCacheValue(userRootDir, cacheKey);
+    if (isObject(cached) && cached.skip === true && cached.version === PROJECT_VERSION)
         return;
     const skillState = await getSkillState(userRootDir);
     if (skillState.state === 'missing') {
@@ -110,7 +112,7 @@ async function checkSkillUnsafe(userRootDir) {
     if (skillState.state === 'installed' ||
         skillState.state === 'not-using-ai-agents' ||
         skillState.state === 'vike-not-from-npm') {
-        await setCacheValue(userRootDir, cacheKey, false);
+        await setCacheValue(userRootDir, cacheKey, { skip: true, version: PROJECT_VERSION });
         return;
     }
     checkType(skillState);

package/dist/node/vite/plugins/pluginUniversalDeploy.js

@@ -1,7 +1,7 @@
 export { pluginUniversalDeploy };
 import { toRou3 } from 'convert-route';
 import { addEntry } from '@universal-deploy/store';
-import universalDeploy, { resolveTargets } from '@universal-deploy/vite';
+import universalDeploy, { precompress, resolveTargets } from '@universal-deploy/vite';
 import { pluginServerEntryInject } from './pluginUniversalDeploy/pluginServerEntryInject.js';
 import { getDeployConfig } from './pluginUniversalDeploy/getDeployConfig.js';
 import { pluginCommon } from './pluginUniversalDeploy/common.js';
@@ -23,10 +23,11 @@ function pluginUniversalDeploy(vikeConfig) {
                 const target = targets.filter((t) => t !== '@cloudflare/vite-plugin')[0];
                 assertUsage(target === undefined, `${target} requires +server — see https://vike.dev/server`);
             }),
+            precompress(vikeConfig.config.precompress),
         ];
     const { serverEntryVike, serverEntryId, serverFilePath } = serverConfig;
     return [
-        ...universalDeploy(),
+        ...universalDeploy({ node: { precompress: vikeConfig.config.precompress } }),
         {
             name: 'vike:pluginUniversalDeploy:entries',
             config() {

package/dist/node/vite/shared/resolveVikeConfigInternal/getPlusFiles.d.ts

@@ -4,7 +4,7 @@ export type { PlusFileValue };
 export type { PlusFile };
 export type { PlusFilesByLocationId };
 import { type LocationId } from './filesystemRouting.js';
-import { type EsbuildCache } from './transpileAndExecuteFile.js';
+import { type VikeTranspileCache } from './transpileAndExecuteFile.js';
 import { type ConfigFile, PointerImportLoaded } from './loadFileAtConfigTime.js';
 import type { FilePathResolved } from '../../../../types/FilePath.js';
 import '../../assertEnvVite.js';
@@ -40,5 +40,5 @@ type PlusFileValue = PlusFileCommon & {
     isExtensionConfig?: undefined;
 };
 type PlusFilesByLocationId = Record<LocationId, PlusFile[]>;
-declare function getPlusFiles(userRootDir: string, esbuildCache: EsbuildCache): Promise<PlusFilesByLocationId>;
+declare function getPlusFiles(userRootDir: string, vikeTranspileCache: VikeTranspileCache): Promise<PlusFilesByLocationId>;
 declare function getPlusFileFromConfigFile(configFile: ConfigFile, isExtensionConfig: boolean, locationId: LocationId, userRootDir: string): PlusFileConfig;

package/dist/node/vite/shared/resolveVikeConfigInternal/getPlusFiles.js

@@ -10,7 +10,7 @@ import { resolvePointerImport } from './resolvePointerImport.js';
 import { getFilePathResolved } from '../getFilePath.js';
 import { assertExtensionsConventions, assertExtensionsRequire } from './assertExtensions.js';
 import '../../assertEnvVite.js';
-async function getPlusFiles(userRootDir, esbuildCache) {
+async function getPlusFiles(userRootDir, vikeTranspileCache) {
     const plusFilePaths = (await crawlPlusFiles(userRootDir)).map(({ filePathAbsoluteUserRootDir }) => getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir }));
     const plusFilesByLocationId = {};
     await Promise.all(plusFilePaths.map(async (filePath) => {
@@ -18,7 +18,7 @@ async function getPlusFiles(userRootDir, esbuildCache) {
             // +config.js files
             const { filePathAbsoluteUserRootDir } = filePath;
             assert(filePathAbsoluteUserRootDir);
-            const { configFile, extendsConfigs } = await loadConfigFile(filePath, userRootDir, [], false, esbuildCache);
+            const { configFile, extendsConfigs } = await loadConfigFile(filePath, userRootDir, [], false, vikeTranspileCache);
             assert(filePath.filePathAbsoluteUserRootDir);
             const locationId = getLocationId(filePathAbsoluteUserRootDir);
             const plusFile = getPlusFileFromConfigFile(configFile, false, locationId, userRootDir);
@@ -65,7 +65,7 @@ async function getPlusFiles(userRootDir, esbuildCache) {
             // We don't have access to the custom config definitions defined by the user yet.
             //  - If `configDef` is `undefined` => we load the file +{configName}.js later.
             //  - We already need to load +meta.js here (to get the custom config definitions defined by the user)
-            await loadValueFile(plusFile, metaBuiltIn, userRootDir, esbuildCache);
+            await loadValueFile(plusFile, metaBuiltIn, userRootDir, vikeTranspileCache);
         }
     }));
     // Make lists element order deterministic

package/dist/node/vite/shared/resolveVikeConfigInternal/loadFileAtConfigTime.d.ts

@@ -4,7 +4,7 @@ export { loadConfigFile };
 export type { ConfigFile };
 export type { PointerImportLoaded };
 import type { FilePathResolved } from '../../../../types/FilePath.js';
-import { type EsbuildCache } from './transpileAndExecuteFile.js';
+import { type VikeTranspileCache } from './transpileAndExecuteFile.js';
 import type { PlusFileValue } from './getPlusFiles.js';
 import { PointerImport } from './resolvePointerImport.js';
 import type { ConfigDefinitionsInternal } from './metaBuiltIn.js';
@@ -14,15 +14,15 @@ type ConfigFile = {
     filePath: FilePathResolved;
     extendsFilePaths: string[];
 };
-declare function loadPointerImport(pointerImport: PointerImportLoaded, userRootDir: string, configName: string, configDefinitions: ConfigDefinitionsInternal, esbuildCache: EsbuildCache): Promise<unknown>;
+declare function loadPointerImport(pointerImport: PointerImportLoaded, userRootDir: string, configName: string, configDefinitions: ConfigDefinitionsInternal, vikeTranspileCache: VikeTranspileCache): Promise<unknown>;
 type PointerImportLoaded = PointerImport & ({
     fileExportValueLoaded: true;
     fileExportValue: unknown;
 } | {
     fileExportValueLoaded: false;
 });
-declare function loadValueFile(interfaceValueFile: PlusFileValue, configDefinitions: ConfigDefinitionsInternal, userRootDir: string, esbuildCache: EsbuildCache): Promise<void>;
-declare function loadConfigFile(configFilePath: FilePathResolved, userRootDir: string, visited: string[], isExtensionConfig: boolean, esbuildCache: EsbuildCache): Promise<{
+declare function loadValueFile(interfaceValueFile: PlusFileValue, configDefinitions: ConfigDefinitionsInternal, userRootDir: string, vikeTranspileCache: VikeTranspileCache): Promise<void>;
+declare function loadConfigFile(configFilePath: FilePathResolved, userRootDir: string, visited: string[], isExtensionConfig: boolean, vikeTranspileCache: VikeTranspileCache): Promise<{
     configFile: ConfigFile;
     extendsConfigs: ConfigFile[];
 }>;

package/dist/node/vite/shared/resolveVikeConfigInternal/loadFileAtConfigTime.js

@@ -17,7 +17,7 @@ import { getConfigDefinedAt } from '../../../../shared-server-client/page-config
 import '../../assertEnvVite.js';
 assertIsNotProductionRuntime();
 // Load pointer import
-async function loadPointerImport(pointerImport, userRootDir, configName, configDefinitions, esbuildCache) {
+async function loadPointerImport(pointerImport, userRootDir, configName, configDefinitions, vikeTranspileCache) {
     // The value of `extends` was already loaded and already used: we don't need the value of `extends` anymore
     if (configName === 'extends')
         return;
@@ -27,14 +27,14 @@ async function loadPointerImport(pointerImport, userRootDir, configName, configD
         return;
     const configDefinedAt = getConfigDefinedAt('Config', configName, pointerImport.fileExportPath);
     assertUsage(pointerImport.fileExportPath.filePathAbsoluteFilesystem, `${configDefinedAt} cannot be defined over an aliased import`);
-    const { fileExports } = await transpileAndExecuteFile(pointerImport.fileExportPath, userRootDir, false, esbuildCache);
+    const { fileExports } = await transpileAndExecuteFile(pointerImport.fileExportPath, userRootDir, false, vikeTranspileCache);
     const fileExportValue = fileExports[pointerImport.fileExportPath.fileExportName];
     pointerImport.fileExportValueLoaded = true;
     assert(pointerImport.fileExportValueLoaded);
     pointerImport.fileExportValue = fileExportValue;
 }
 // Load +{configName}.js
-async function loadValueFile(interfaceValueFile, configDefinitions, userRootDir, esbuildCache) {
+async function loadValueFile(interfaceValueFile, configDefinitions, userRootDir, vikeTranspileCache) {
     const { configName } = interfaceValueFile;
     const configDef = getConfigDefinitionOptional(configDefinitions, configName);
     // Only load value files with `env.config===true`
@@ -43,7 +43,7 @@ async function loadValueFile(interfaceValueFile, configDefinitions, userRootDir,
     interfaceValueFile.isNotLoaded = false;
     assert(!interfaceValueFile.isNotLoaded);
     interfaceValueFile.fileExportsByConfigName = {};
-    const { fileExports } = await transpileAndExecuteFile(interfaceValueFile.filePath, userRootDir, false, esbuildCache);
+    const { fileExports } = await transpileAndExecuteFile(interfaceValueFile.filePath, userRootDir, false, vikeTranspileCache);
     const { filePathToShowToUser } = interfaceValueFile.filePath;
     assertPlusFileExport(fileExports, filePathToShowToUser, configName);
     Object.entries(fileExports).forEach(([exportName, configValue]) => {
@@ -52,11 +52,11 @@ async function loadValueFile(interfaceValueFile, configDefinitions, userRootDir,
     });
 }
 // Load +config.js, including all its extends pointer imports
-async function loadConfigFile(configFilePath, userRootDir, visited, isExtensionConfig, esbuildCache) {
+async function loadConfigFile(configFilePath, userRootDir, visited, isExtensionConfig, vikeTranspileCache) {
     const { filePathAbsoluteFilesystem } = configFilePath;
     assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem);
-    const { fileExports } = await transpileAndExecuteFile(configFilePath, userRootDir, isExtensionConfig, esbuildCache);
-    const { extendsConfigs, extendsFilePaths } = await loadExtendsConfigs(fileExports, configFilePath, userRootDir, [...visited, filePathAbsoluteFilesystem], esbuildCache);
+    const { fileExports } = await transpileAndExecuteFile(configFilePath, userRootDir, isExtensionConfig, vikeTranspileCache);
+    const { extendsConfigs, extendsFilePaths } = await loadExtendsConfigs(fileExports, configFilePath, userRootDir, [...visited, filePathAbsoluteFilesystem], vikeTranspileCache);
     const configFile = {
         fileExports,
         filePath: configFilePath,
@@ -72,7 +72,7 @@ function assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem) {
     assert(loop[0] === filePathAbsoluteFilesystem);
     assertUsage(idx === -1, `Infinite extends loop ${[...loop, filePathAbsoluteFilesystem].join('>')}`);
 }
-async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir, visited, esbuildCache) {
+async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir, visited, vikeTranspileCache) {
     const { extendsPointerImportData, extendsConfigs } = getExtendsPointerImportData(configFileExports, configFilePath);
     const extendsConfigFiles = [];
     extendsPointerImportData.map((pointerImportData) => {
@@ -80,7 +80,7 @@ async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir
         assert(filePath.filePathAbsoluteFilesystem);
         extendsConfigFiles.push(filePath);
     });
-    const results = await Promise.all(extendsConfigFiles.map(async (configFilePath) => await loadConfigFile(configFilePath, userRootDir, visited, true, esbuildCache)));
+    const results = await Promise.all(extendsConfigFiles.map(async (configFilePath) => await loadConfigFile(configFilePath, userRootDir, visited, true, vikeTranspileCache)));
     results.forEach((result) => {
         extendsConfigs.push(result.configFile);
         extendsConfigs.push(...result.extendsConfigs);

package/dist/node/vite/shared/resolveVikeConfigInternal/metaBuiltIn.js

@@ -244,6 +244,10 @@ const metaBuiltIn = {
         env: { server: true },
         global: true,
     },
+    precompress: {
+        env: { config: true },
+        global: true,
+    },
     cli: {
         env: { config: true },
         global: true,

package/dist/node/vite/shared/resolveVikeConfigInternal/pointerImports.d.ts

@@ -1,9 +1,11 @@
 export { transformPointerImports };
 export { parsePointerImportData };
 export { assertPointerImportPath };
+export { pointerImportAttributeSuffix };
 export type { PointerImportData };
 import '../../assertEnvVite.js';
-declare function transformPointerImports(code: string, filePathToShowToUser2: string, pointerImports: Record<string, boolean> | 'all', skipWarnings?: true): string | null;
+declare const pointerImportAttributeSuffix = "?vike:pointer";
+declare function transformPointerImports(code: string, pointerImports: Record<string, boolean> | 'all'): string | null;
 /**
  * Data Structure for [pointer imports](https://vike.dev/config#pointer-imports):
  *   `import { someExport as someImport } from './some-file'`