vike 0.4.247 → 0.4.249

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

@@ -0,0 +1,67 @@
+export { createPageContextClientSide };
+declare function createPageContextClientSide(): Promise<{
+    _isOriginalObject: true;
+    isPageContext: true;
+} & {
+    isClientSide: true;
+    isPrerendering: false;
+    isHydration: true;
+    _globalContext: {
+        _globalConfigPublic: {
+            pages: {
+                [k: string]: {
+                    config: import("../../types/index.js").ConfigResolved;
+                    _source: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+                    _sources: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+                    _from: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+                } & ({
+                    route: import("../../types/Config.js").Route;
+                    isErrorPage?: undefined;
+                } | {
+                    route?: undefined;
+                    isErrorPage: true;
+                });
+            };
+            config: import("../../types/index.js").ConfigResolved;
+            _source: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+            _sources: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+            _from: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+        };
+        pages: {
+            [k: string]: {
+                config: import("../../types/index.js").ConfigResolved;
+                _source: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+                _sources: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+                _from: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+            } & ({
+                route: import("../../types/Config.js").Route;
+                isErrorPage?: undefined;
+            } | {
+                route?: undefined;
+                isErrorPage: true;
+            });
+        };
+        config: import("../../types/index.js").ConfigResolved;
+        _source: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+        _sources: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+        _from: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+        isGlobalContext: true;
+        _isOriginalObject: true;
+        _virtualFileExportsGlobalEntry: unknown;
+        _pageFilesAll: import("../../shared-server-client/getPageFiles.js").PageFile[];
+        _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
+        _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+    } & {
+        isClientSide: true;
+    };
+    _pageFilesAll: import("../../shared-server-client/getPageFiles.js").PageFile[];
+    isBackwardNavigation: null;
+    isHistoryNavigation: null;
+    _hasPageContextFromServer: true;
+} & {
+    pageId: string;
+    routeParams: Record<string, string>;
+} & import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").GlobalConfigPublic & import("../../shared-server-client/getPageFiles.js").PageContextConfig & {
+    _pageFilesLoaded: import("../../shared-server-client/getPageFiles.js").PageFile[];
+}>;

package/dist/client/runtime-server-routing/createPageContextClientSide.js

@@ -0,0 +1,41 @@
+export { createPageContextClientSide };
+import { assertUsage, updateType, objectAssign } from './utils.js';
+import { getPageContextSerializedInHtml } from '../shared/getJsonSerializedInHtml.js';
+import { loadPageConfigsLazyClientSide, } from '../shared/loadPageConfigsLazyClientSide.js';
+import { getCurrentUrl } from '../shared/getCurrentUrl.js';
+import { createPageContextObject, createPageContextShared } from '../../shared-server-client/createPageContextShared.js';
+import { getGlobalContextClientInternal } from './getGlobalContextClientInternal.js';
+import { preparePageContextForPublicUsageClient, } from './preparePageContextForPublicUsageClient.js';
+import { execHook } from '../../shared-server-client/hooks/execHook.js';
+const urlFirst = getCurrentUrl({ withoutHash: true });
+async function createPageContextClientSide() {
+    const globalContext = await getGlobalContextClientInternal();
+    const pageContextCreated = createPageContextObject();
+    objectAssign(pageContextCreated, {
+        isClientSide: true,
+        isPrerendering: false,
+        isHydration: true,
+        _globalContext: globalContext,
+        _pageFilesAll: globalContext._pageFilesAll, // TO-DO/next-major-release: remove
+        isBackwardNavigation: null,
+        isHistoryNavigation: null,
+        _hasPageContextFromServer: true,
+    });
+    objectAssign(pageContextCreated, getPageContextSerializedInHtml());
+    // Sets pageContext.config to global configs
+    updateType(pageContextCreated, createPageContextShared(pageContextCreated, globalContext._globalConfigPublic));
+    // Sets pageContext.config to local configs (overrides the pageContext.config set above)
+    updateType(pageContextCreated, await loadPageConfigsLazyClientSideAndExecHook(pageContextCreated));
+    assertPristineUrl();
+    return pageContextCreated;
+}
+function assertPristineUrl() {
+    const urlCurrent = getCurrentUrl({ withoutHash: true });
+    assertUsage(urlFirst === urlCurrent, `The URL was manipulated before the hydration finished ('${urlFirst}' to '${urlCurrent}'). Ensure the hydration has finished before manipulating the URL. Consider using the onHydrationEnd() hook.`);
+}
+async function loadPageConfigsLazyClientSideAndExecHook(pageContext) {
+    const pageContextAddendum = await loadPageConfigsLazyClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._globalContext._pageConfigs, pageContext._globalContext._pageConfigGlobal);
+    objectAssign(pageContext, pageContextAddendum);
+    await execHook('onCreatePageContext', pageContext, preparePageContextForPublicUsageClient);
+    return pageContext;
+}

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

@@ -0,0 +1,21 @@
+import { assertServerRouting } from '../../utils/assertRoutingType.js';
+assertServerRouting();
+import { createPageContextClientSide } from './createPageContextClientSide.js';
+import { execHookOnRenderClient } from '../shared/execHookOnRenderClient.js';
+import { assertSingleInstance_onClientEntryServerRouting } from './utils.js';
+import { removeFoucBuster } from '../shared/removeFoucBuster.js';
+import { execHook } from '../../shared-server-client/hooks/execHook.js';
+import { preparePageContextForPublicUsageClient } from './preparePageContextForPublicUsageClient.js';
+import { setVirtualFileExportsGlobalEntry } from '../shared/getGlobalContextClientInternalShared.js';
+// @ts-expect-error
+import * as virtualFileExportsGlobalEntry from 'virtual:vike:global-entry:client:server-routing';
+assertSingleInstance_onClientEntryServerRouting(import.meta.env.PROD);
+setVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry);
+if (import.meta.env.DEV)
+    removeFoucBuster();
+hydrate();
+async function hydrate() {
+    const pageContext = await createPageContextClientSide();
+    await execHookOnRenderClient(pageContext, preparePageContextForPublicUsageClient);
+    await execHook('onHydrationEnd', pageContext, preparePageContextForPublicUsageClient);
+}

package/dist/client/runtime-server-routing/getGlobalContextClientInternal.d.ts

@@ -0,0 +1,52 @@
+export { getGlobalContextClientInternal };
+export type { GlobalContextClientInternalWithServerRouting };
+type GlobalContextClientInternalWithServerRouting = Awaited<ReturnType<typeof getGlobalContextClientInternal>>;
+declare function getGlobalContextClientInternal(): Promise<{
+    _globalConfigPublic: {
+        pages: {
+            [k: string]: {
+                config: import("../../types/index.js").ConfigResolved;
+                _source: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+                _sources: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+                _from: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+            } & ({
+                route: import("../../types/Config.js").Route;
+                isErrorPage?: undefined;
+            } | {
+                route?: undefined;
+                isErrorPage: true;
+            });
+        };
+        config: import("../../types/index.js").ConfigResolved;
+        _source: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+        _sources: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+        _from: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+    };
+    pages: {
+        [k: string]: {
+            config: import("../../types/index.js").ConfigResolved;
+            _source: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+            _sources: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+            _from: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+        } & ({
+            route: import("../../types/Config.js").Route;
+            isErrorPage?: undefined;
+        } | {
+            route?: undefined;
+            isErrorPage: true;
+        });
+    };
+    config: import("../../types/index.js").ConfigResolved;
+    _source: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+    _sources: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+    _from: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+    isGlobalContext: true;
+    _isOriginalObject: true;
+    _virtualFileExportsGlobalEntry: unknown;
+    _pageFilesAll: import("../../shared-server-client/getPageFiles.js").PageFile[];
+    _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
+    _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
+} & {
+    isClientSide: true;
+}>;

package/dist/client/runtime-server-routing/preparePageContextForPublicUsageClient.d.ts

@@ -0,0 +1,9 @@
+export { preparePageContextForPublicUsageClient };
+export type { PageContextForPublicUsageClient };
+import type { PageContextConfig } from '../../shared-server-client/getPageFiles.js';
+import type { PageContextInternalClient_ServerRouting } from '../../types/PageContext.js';
+import type { PageContextPrepareMinimum } from '../../shared-server-client/preparePageContextForPublicUsage.js';
+type PageContextForPublicUsageClient = PageContextPrepareMinimum & PageContextInternalClient_ServerRouting & PageContextConfig;
+declare function preparePageContextForPublicUsageClient<PageContext extends PageContextForPublicUsageClient>(pageContext: PageContext): PageContext & {
+    Page: unknown;
+};

package/dist/client/shared/execHookOnRenderClient.d.ts

@@ -0,0 +1,13 @@
+export { execHookOnRenderClient };
+export type { PageContextBeforeRenderClient };
+import type { PageFile, PageContextConfig } from '../../shared-server-client/getPageFiles.js';
+import type { PageContextForPublicUsageClientShared } from './preparePageContextForPublicUsageClientShared.js';
+import type { GlobalContextClientInternalShared } from './getGlobalContextClientInternalShared.js';
+type PageContextBeforeRenderClient = {
+    _pageFilesLoaded: PageFile[];
+    urlOriginal?: string;
+    urlPathname?: string;
+    pageId: string;
+    _globalContext: GlobalContextClientInternalShared;
+} & PageContextConfig & PageContextForPublicUsageClientShared;
+declare function execHookOnRenderClient<PageContext extends PageContextBeforeRenderClient>(pageContext: PageContext, prepareForPublicUsage: (pageConfig: PageContext) => PageContext): Promise<void>;

package/dist/client/shared/execHookOnRenderClient.js

@@ -0,0 +1,56 @@
+export { execHookOnRenderClient };
+import { assert, assertUsage } from '../runtime-server-routing/utils.js';
+import { getHookFromPageContext } from '../../shared-server-client/hooks/getHook.js';
+import { execHookDirectSingle } from '../../shared-server-client/hooks/execHook.js';
+async function execHookOnRenderClient(pageContext, prepareForPublicUsage) {
+    let hook = null;
+    {
+        const renderHook = getHookFromPageContext(pageContext, 'render');
+        hook = renderHook;
+    }
+    {
+        const renderHook = getHookFromPageContext(pageContext, 'onRenderClient');
+        if (renderHook) {
+            hook = renderHook;
+        }
+    }
+    if (!hook) {
+        const urlToShowToUser = getUrlToShowToUser(pageContext);
+        assert(urlToShowToUser);
+        if (pageContext._globalContext._pageConfigs.length > 0) {
+            // V1 design
+            assertUsage(false, `No onRenderClient() hook defined for URL '${urlToShowToUser}', but it's needed, see https://vike.dev/onRenderClient`);
+        }
+        else {
+            // TO-DO/next-major-release: remove
+            // V0.4 design
+            const pageClientsFilesLoaded = pageContext._pageFilesLoaded.filter((p) => p.fileType === '.page.client');
+            let errMsg;
+            if (pageClientsFilesLoaded.length === 0) {
+                errMsg = 'No file `*.page.client.*` found for URL ' + urlToShowToUser;
+            }
+            else {
+                errMsg =
+                    'One of the following files should export a render() hook: ' +
+                        pageClientsFilesLoaded.map((p) => p.filePath).join(' ');
+            }
+            assertUsage(false, errMsg);
+        }
+    }
+    // We don't use a try-catch wrapper because rendering errors are usually handled by the UI framework. (E.g. React's Error Boundaries.)
+    await execHookDirectSingle(hook, pageContext, prepareForPublicUsage);
+}
+function getUrlToShowToUser(pageContext) {
+    let url;
+    // try/catch to avoid passToClient assertUsage() (although: this may not be needed anymore, since we're now accessing pageContext and not pageContextForPublicUsage)
+    try {
+        url =
+            // Client Routing
+            pageContext.urlPathname ??
+                // Server Routing
+                pageContext.urlOriginal;
+    }
+    catch { }
+    url = url ?? window.location.href;
+    return url;
+}

package/dist/client/shared/getGlobalContextClientInternalShared.d.ts

@@ -0,0 +1,67 @@
+export { getGlobalContext };
+export { getGlobalContextSync };
+export { setVirtualFileExportsGlobalEntry };
+export { getGlobalContextClientInternalShared };
+export type GlobalContextClientInternalShared = GlobalContextClientInternal | GlobalContextClientInternalWithServerRouting;
+import type { GlobalContextClientInternal } from '../runtime-client-routing/getGlobalContextClientInternal.js';
+import type { GlobalContextClientInternalWithServerRouting } from '../runtime-server-routing/getGlobalContextClientInternal.js';
+declare function getGlobalContextClientInternalShared(): Promise<{
+    _globalConfigPublic: {
+        pages: {
+            [k: string]: {
+                config: import("../../types/index.js").ConfigResolved;
+                _source: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+                _sources: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+                _from: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+            } & ({
+                route: import("../../types/Config.js").Route;
+                isErrorPage?: undefined;
+            } | {
+                route?: undefined;
+                isErrorPage: true;
+            });
+        };
+        config: import("../../types/index.js").ConfigResolved;
+        _source: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+        _sources: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+        _from: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+    };
+    pages: {
+        [k: string]: {
+            config: import("../../types/index.js").ConfigResolved;
+            _source: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+            _sources: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+            _from: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+        } & ({
+            route: import("../../types/Config.js").Route;
+            isErrorPage?: undefined;
+        } | {
+            route?: undefined;
+            isErrorPage: true;
+        });
+    };
+    config: import("../../types/index.js").ConfigResolved;
+    _source: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+    _sources: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+    _from: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+    isGlobalContext: true;
+    _isOriginalObject: true;
+    _virtualFileExportsGlobalEntry: unknown;
+    _pageFilesAll: import("../../shared-server-client/getPageFiles.js").PageFile[];
+    _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
+    _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
+} & {
+    /**
+     * Whether the environment is the client-side:
+     * - In the browser, the value is `true`.
+     * - Upon SSR and pre-rendering, the value is `false`.
+     *
+     * https://vike.dev/globalContext#isClientSide
+     */
+    isClientSide: true;
+}>;
+type TypeIsNotExported = never;
+declare function getGlobalContext(): Promise<TypeIsNotExported>;
+declare function getGlobalContextSync(): TypeIsNotExported;
+declare function setVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry: unknown): Promise<void>;

package/dist/client/shared/getGlobalContextClientInternalShared.js

@@ -0,0 +1,66 @@
+// Public usage
+export { getGlobalContext };
+export { getGlobalContextSync };
+export { setVirtualFileExportsGlobalEntry };
+// Internal usage
+export { getGlobalContextClientInternalShared };
+import { createGlobalContextShared, getGlobalContextSyncErrMsg, } from '../../shared-server-client/createGlobalContextShared.js';
+import { getGlobalContextSerializedInHtml } from './getJsonSerializedInHtml.js';
+import { assert, assertUsage, genPromise, getGlobalObject, objectAssign, checkType } from './utils.js';
+const globalObject = getGlobalObject('getGlobalContextClientInternalShared.ts', (() => {
+    const { promise: globalContextInitialPromise, resolve: globalContextInitialPromiseResolve } = genPromise();
+    return {
+        globalContextInitialPromise,
+        globalContextInitialPromiseResolve,
+    };
+})());
+async function getGlobalContextClientInternalShared() {
+    // Get
+    if (globalObject.globalContextPromise) {
+        const globalContext = await globalObject.globalContextPromise;
+        return globalContext;
+    }
+    // Create
+    const globalContextPromise = createGlobalContextShared(globalObject.virtualFileExportsGlobalEntry, globalObject, () => {
+        const globalContextAddendum = {
+            /**
+             * Whether the environment is the client-side:
+             * - In the browser, the value is `true`.
+             * - Upon SSR and pre-rendering, the value is `false`.
+             *
+             * https://vike.dev/globalContext#isClientSide
+             */
+            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;
+    const globalContext = await globalObject.globalContextPromise;
+    assert(globalContext);
+    checkType(globalContext);
+    return globalContext;
+}
+function getGlobalContextSync() {
+    const { globalContext } = globalObject;
+    assertUsage(globalContext, getGlobalContextSyncErrMsg);
+    checkType(globalContext);
+    return globalContext;
+}
+async function setVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry) {
+    // HMR => virtualFileExportsGlobalEntry differ
+    if (globalObject.virtualFileExportsGlobalEntry !== virtualFileExportsGlobalEntry) {
+        delete globalObject.globalContextPromise;
+        globalObject.virtualFileExportsGlobalEntry = virtualFileExportsGlobalEntry;
+        // Eagerly call +onCreateGlobalContext() hooks
+        await getGlobalContextClientInternalShared();
+    }
+}

package/dist/client/shared/getJsonSerializedInHtml.js

@@ -0,0 +1,38 @@
+export { getPageContextSerializedInHtml };
+export { getGlobalContextSerializedInHtml };
+import { parse } from '@brillout/json-serializer/parse';
+import { hasProp, assert, assertUsage } from './utils.js';
+import { htmlElementId_globalContext, htmlElementId_pageContext } from '../../shared-server-client/htmlElementIds.js';
+// elements should exist because:
+// 1. <script id="vike_pageContext" type="application/json"> appears before the <script> that loads Vike's client runtime (which includes this file)
+// 2. <script id="vike_pageContext" type="application/json"> is neither async nor defer
+// See https://github.com/vikejs/vike/pull/1271
+function getPageContextSerializedInHtml() {
+    const pageContextSerializedInHtml = findAndParseJson(htmlElementId_pageContext);
+    assert(hasProp(pageContextSerializedInHtml, 'pageId', 'string'));
+    assert(hasProp(pageContextSerializedInHtml, 'routeParams', 'string{}'));
+    return pageContextSerializedInHtml;
+}
+function getGlobalContextSerializedInHtml() {
+    const globalContextSerializedInHtml = findAndParseJson(htmlElementId_globalContext);
+    return globalContextSerializedInHtml;
+}
+function findAndParseJson(id) {
+    const elem = document.getElementById(id);
+    assertUsage(elem, 
+    // It seems like it can be missing when HTML is malformed: https://github.com/vikejs/vike/issues/913
+    `Couldn't find #${id} (which Vike automatically injects in the HTML): make sure it exists (i.e. don't remove it and make sure your HTML isn't malformed)`);
+    const jsonStr = elem.textContent;
+    assert(jsonStr);
+    const json = parse(jsonStr, {
+        // Prevent Google from crawling URLs in JSON:
+        // - https://github.com/vikejs/vike/pull/2603
+        // - https://github.com/brillout/json-serializer/blob/38edbb9945de4938da1e65d6285ce1dd123a45ef/test/main.spec.ts#L44-L95
+        reviver(_key, value) {
+            if (typeof value === 'string') {
+                return { replacement: value.replaceAll('\\/', '/'), resolved: false };
+            }
+        },
+    });
+    return json;
+}

package/dist/client/shared/loadPageConfigsLazyClientSide.d.ts

@@ -0,0 +1,17 @@
+export { loadPageConfigsLazyClientSide };
+export type { PageContext_loadPageConfigsLazyClientSide };
+export { isErrorFetchingStaticAssets };
+import { type PageFile } from '../../shared-server-client/getPageFiles.js';
+import type { PageConfigGlobalRuntime, PageConfigRuntime } from '../../types/PageConfig.js';
+type PageContext_loadPageConfigsLazyClientSide = {
+    pageId: string;
+    _pageFilesAll: PageFile[];
+    _globalContext: {
+        _pageConfigs: PageConfigRuntime[];
+        _pageConfigGlobal: PageConfigGlobalRuntime;
+    };
+};
+declare function loadPageConfigsLazyClientSide(pageId: string, pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[], pageConfigGlobal: PageConfigGlobalRuntime): Promise<import("../../shared-server-client/getPageFiles.js").PageContextConfig & {
+    _pageFilesLoaded: PageFile[];
+}>;
+declare function isErrorFetchingStaticAssets(err: unknown): boolean;

package/dist/client/shared/loadPageConfigsLazyClientSide.js

@@ -0,0 +1,61 @@
+export { loadPageConfigsLazyClientSide };
+export { isErrorFetchingStaticAssets };
+import { getPageFilesClientSide } from '../../shared-server-client/getPageFiles.js';
+import { resolvePageContextConfig } from '../../shared-server-client/page-configs/resolveVikeConfigPublic.js';
+import { findPageConfig } from '../../shared-server-client/page-configs/findPageConfig.js';
+import { loadAndParseVirtualFilePageEntry } from '../../shared-server-client/page-configs/loadAndParseVirtualFilePageEntry.js';
+import { objectAssign } from '../runtime-server-routing/utils.js';
+const errStamp = '_isAssetsError';
+async function loadPageConfigsLazyClientSide(pageId, pageFilesAll, pageConfigs, pageConfigGlobal) {
+    const pageFilesClientSide = getPageFilesClientSide(pageFilesAll, pageId);
+    const pageConfig = findPageConfig(pageConfigs, pageId);
+    let pageConfigLoaded;
+    try {
+        // prettier-ignore
+        // biome-ignore format:
+        const result = await Promise.all([
+            pageConfig && loadAndParseVirtualFilePageEntry(pageConfig, import.meta.env.DEV),
+            ...pageFilesClientSide.map((p) => p.loadFile?.()),
+        ]);
+        pageConfigLoaded = result[0];
+    }
+    catch (err) {
+        if (isFetchError(err)) {
+            Object.assign(err, { [errStamp]: true });
+        }
+        else {
+            // Syntax error in user file
+        }
+        throw err;
+    }
+    const pageContextAddendum = {};
+    objectAssign(pageContextAddendum, resolvePageContextConfig(pageFilesClientSide, pageConfigLoaded, pageConfigGlobal));
+    objectAssign(pageContextAddendum, { _pageFilesLoaded: pageFilesClientSide });
+    return pageContextAddendum;
+}
+function isErrorFetchingStaticAssets(err) {
+    if (!err) {
+        return false;
+    }
+    return err[errStamp] === true;
+}
+// https://stackoverflow.com/questions/75928310/how-to-detect-that-import-some-url-failed-because-some-url-isnt-a-javasc
+function isFetchError(err) {
+    if (!(err instanceof Error))
+        return false;
+    // https://github.com/stacks-network/clarity-js-sdk/blob/e757666b59af00b5db04dd1bf0df016e3a459ea2/packages/clarity/src/providers/registry.ts#L40-L45
+    // https://github.com/modernweb-dev/web/blob/0a59b56e4c1b50af81fbf4588f36a1ceb71f3976/integration/test-runner/tests/test-failure/runTestFailureTest.ts#L11-L18
+    const FAILED_TO_FETCH_MESSAGES = [
+        // chromium
+        'Failed to fetch dynamically imported module',
+        // firefox
+        'error loading dynamically imported module',
+        // safari
+        'Importing a module script failed',
+        // ??
+        'error resolving module specifier',
+        // ??
+        'failed to resolve module',
+    ];
+    return FAILED_TO_FETCH_MESSAGES.some((s) => err.message.toLowerCase().includes(s.toLowerCase()));
+}

package/dist/client/shared/preparePageContextForPublicUsageClientShared.d.ts

@@ -0,0 +1,15 @@
+export { preparePageContextForPublicUsageClientShared };
+export { preparePageContextForPublicUsageClientMinimal };
+export type { PageContextForPublicUsageClientShared };
+import type { PageContextConfig } from '../../shared-server-client/getPageFiles.js';
+import { type PageContextPrepareMinimum } from '../../shared-server-client/preparePageContextForPublicUsage.js';
+import type { PageContextInternalClient } from '../../types/PageContext.js';
+type PageContextForPublicUsageClientShared = PageContextPrepareMinimum & PageContextInternalClient & PageContextConfig;
+declare function preparePageContextForPublicUsageClientShared<PageContext extends PageContextForPublicUsageClientShared>(pageContext: PageContext): PageContext & {
+    Page: unknown;
+};
+declare function preparePageContextForPublicUsageClientMinimal<PageContext extends PageContextPrepareMinimum>(pageContext: PageContext): PageContext & {
+    _isProxyObject: true;
+    _originalObject: PageContext;
+    dangerouslyUseInternals: PageContext;
+};

package/dist/client/shared/preparePageContextForPublicUsageClientShared.js

@@ -0,0 +1,39 @@
+export { preparePageContextForPublicUsageClientShared };
+export { preparePageContextForPublicUsageClientMinimal };
+import { objectAssign } from '../runtime-server-routing/utils.js';
+import { assertPropertyGetters, preparePageContextForPublicUsage, } from '../../shared-server-client/preparePageContextForPublicUsage.js';
+function preparePageContextForPublicUsageClientShared(pageContext) {
+    // TO-DO/soon/proxy: use proxy
+    const Page = pageContext.config?.Page ||
+        // TO-DO/next-major-release: remove
+        pageContext.exports?.Page;
+    objectAssign(pageContext, { Page });
+    // TO-DO/next-major-release: after we remove supportVueReactiviy() we can call this later inside the agnostic preparePageContextForPublicUsage()
+    assertPropertyGetters(pageContext);
+    // TO-DO/next-major-release: remove
+    // - Requires https://github.com/vikejs/vike-vue/issues/198
+    // - Last time I tried to remove it (https://github.com/vikejs/vike/commit/705fd23598d9d69bf46a52c8550216cd7117ce71) the tests were failing as expected: only the Vue integrations that used shallowReactive() failed.
+    supportVueReactiviy(pageContext);
+    return preparePageContextForPublicUsageClientMinimal(pageContext);
+}
+function preparePageContextForPublicUsageClientMinimal(pageContext) {
+    const pageContextPublic = preparePageContextForPublicUsage(pageContext);
+    return pageContextPublic;
+}
+// With Vue + Client Routing, the `pageContext` is made reactive:
+// ```js
+// import { reactive } from 'vue'
+// // See /examples/vue-full/renderer/createVueApp.ts
+// const pageContextReactive = reactive(pageContext)
+// ```
+function supportVueReactiviy(pageContext) {
+    resolveGetters(pageContext);
+}
+// Remove property descriptor getters because they break Vue's reactivity.
+// E.g. resolve the `pageContext.urlPathname` getter.
+function resolveGetters(pageContext) {
+    Object.entries(pageContext).forEach(([key, val]) => {
+        delete pageContext[key];
+        pageContext[key] = val;
+    });
+}

package/dist/client/shared/removeFoucBuster.js

@@ -0,0 +1,51 @@
+export { removeFoucBuster };
+import { assert } from './utils.js';
+// See also:
+// - Alternative approach of exactly injecting what Vite injects:
+//   - https://github.com/remix-run/remix/issues/8830#issuecomment-1968368351
+//   - https://github.com/rakkasjs/rakkasjs/blob/7d75ccc915e93bca04e6bab37dc6abdb68a85e4a/packages/rakkasjs/src/features/pages/middleware.tsx#L701
+// - https://github.com/remix-run/remix/issues/8830
+function removeFoucBuster() {
+    // In production removeFoucBuster() is expected to be have been removed by tree shaking
+    assert(import.meta.env.DEV);
+    let sleep = 2;
+    setTimeout(runClean, sleep);
+    return;
+    function runClean() {
+        const isCleaned = clean();
+        if (!isCleaned) {
+            if (sleep < 1000)
+                sleep = 2 * sleep;
+            setTimeout(runClean, sleep);
+        }
+    }
+}
+function clean() {
+    const VITE_ID = 'data-vite-dev-id';
+    const injectedByVite = [...document.querySelectorAll(`style[${VITE_ID}]`)].map((style) => style.getAttribute(VITE_ID));
+    // ```
+    // <link rel="stylesheet" type="text/css" href="/renderer/css/index.css?direct">
+    // <link rel="stylesheet" type="text/css" href="/renderer/Layout.css?direct">
+    // ```
+    const suffix = '?direct';
+    // <link> defined by:
+    //  - https://github.com/vikejs/vike/blob/fae90a15d88e5e87ca9fcbb54cf2dc8773d2f229/vike/server/runtime/html/injectAssets/inferHtmlTags.ts#L35
+    //  - https://github.com/vikejs/vike/blob/fae90a15d88e5e87ca9fcbb54cf2dc8773d2f229/vike/server/runtime/renderPageServer/getPageAssets.ts#L68
+    const injectedByVike = [...document.querySelectorAll(`link[rel="stylesheet"][type="text/css"][href$="${suffix}"]`)];
+    let isCleaned = true;
+    injectedByVike.forEach((linkVike) => {
+        const href = linkVike.getAttribute('href');
+        assert(href && href.endsWith(suffix));
+        let filePathAbsoluteUserRootDir = href.slice(0, -suffix.length);
+        const prefix = '/@fs/';
+        if (filePathAbsoluteUserRootDir.startsWith(prefix))
+            filePathAbsoluteUserRootDir = filePathAbsoluteUserRootDir.slice(prefix.length);
+        if (injectedByVite.some((filePathAbsoluteFilesystem) => filePathAbsoluteFilesystem.endsWith(filePathAbsoluteUserRootDir))) {
+            linkVike.remove();
+        }
+        else {
+            isCleaned = false;
+        }
+    });
+    return isCleaned;
+}