vike 0.0.0-alpha.0 → 0.4.142-commit-6eb0dd3

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

@@ -0,0 +1,22 @@
+export * from '../server-routing-runtime/utils.js';
+export * from '../../utils/assert.js';
+export * from '../../utils/assertSingleInstance.js';
+export * from '../../shared/hooks/executeHook.js';
+export * from '../../utils/getCurrentUrl.js';
+export * from '../../utils/getGlobalObject.js';
+export * from '../../utils/hasProp.js';
+export * from '../../utils/isBrowser.js';
+export * from '../../utils/isCallable.js';
+export * from '../../utils/isObject.js';
+export * from '../../utils/isPlainObject.js';
+export * from '../../utils/isReact.js';
+export * from '../../utils/isEquivalentError.js';
+export * from '../../utils/objectAssign.js';
+export * from '../../utils/parseUrl.js';
+export * from '../../utils/projectInfo.js';
+export * from '../../utils/PromiseType.js';
+export * from '../../utils/serverSideRouteTo.js';
+export * from '../../utils/sleep.js';
+export * from '../../utils/slice.js';
+export * from '../../utils/throttle.js';
+export * from '../../utils/assertRoutingType.js';

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

@@ -0,0 +1,28 @@
+// Utils needed by Client Routing.
+// We assume all runtime entries will load this utils.ts file
+import { onLoad } from './onLoad.js';
+onLoad();
+// We load the Server Routing utils: we tolerate the tiny amount of code that is only needed by Server Routing (only 1-2 lines).
+// We re-export some of the utils down below only to list the utils needed by Client Routing.
+export * from '../server-routing-runtime/utils.js';
+export * from '../../utils/assert.js';
+export * from '../../utils/assertSingleInstance.js';
+export * from '../../shared/hooks/executeHook.js';
+export * from '../../utils/getCurrentUrl.js';
+export * from '../../utils/getGlobalObject.js';
+export * from '../../utils/hasProp.js';
+export * from '../../utils/isBrowser.js';
+export * from '../../utils/isCallable.js';
+export * from '../../utils/isObject.js';
+export * from '../../utils/isPlainObject.js';
+export * from '../../utils/isReact.js';
+export * from '../../utils/isEquivalentError.js';
+export * from '../../utils/objectAssign.js';
+export * from '../../utils/parseUrl.js';
+export * from '../../utils/projectInfo.js';
+export * from '../../utils/PromiseType.js';
+export * from '../../utils/serverSideRouteTo.js';
+export * from '../../utils/sleep.js';
+export * from '../../utils/slice.js';
+export * from '../../utils/throttle.js';
+export * from '../../utils/assertRoutingType.js';

package/dist/esm/client/node.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/client/node.js

@@ -0,0 +1,9 @@
+import { assertUsage } from './server-routing-runtime/utils.js';
+assertUsage(false, [
+    'Following imports are forbidden on the client-side:',
+    "  import { something } from 'vike/server'",
+    // TODO/v1-release: remove this line (also remove s above in `s/Following imports/Following import/`)
+    "  import { something } from 'vike'",
+    'Did you mean the following instead?',
+    "  import { something } from 'vike/client/router'"
+].join('\n'), { showStackTrace: true });

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

@@ -0,0 +1 @@
+import './pageFiles';

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

@@ -0,0 +1,17 @@
+import { assertServerRouting } from '../../utils/assertRoutingType.js';
+assertServerRouting();
+import './pageFiles';
+import { getPageContext } from './getPageContext.js';
+import { executeOnRenderClientHook } from '../shared/executeOnRenderClientHook.js';
+import { assertHook } from '../../shared/hooks/getHook.js';
+import { onClientEntry_ServerRouting } from './utils.js';
+// @ts-ignore Since dist/cjs/client/ is never used, we can ignore this error.
+const isProd = import.meta.env.PROD;
+onClientEntry_ServerRouting(isProd);
+hydrate();
+async function hydrate() {
+    const pageContext = await getPageContext();
+    await executeOnRenderClientHook(pageContext, false);
+    assertHook(pageContext, 'onHydrationEnd');
+    await pageContext.exports.onHydrationEnd?.(pageContext);
+}

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

@@ -0,0 +1,14 @@
+export { getPageContext };
+declare function getPageContext(): Promise<{
+    _pageId: string;
+    _hasPageContextFromServer: true;
+} & {
+    isHydration: true;
+    isBackwardNavigation: null;
+    _hasPageContextFromClient: boolean;
+} & {
+    _pageFilesAll: import("../../shared/getPageFiles/getPageFileObject.js").PageFile[];
+    _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfig[];
+} & import("../../shared/getPageFiles/getExports.js").PageContextExports & {
+    _pageFilesLoaded: import("../../shared/getPageFiles/getPageFileObject.js").PageFile[];
+}>;

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

@@ -0,0 +1,36 @@
+import { assertUsage, assertWarning, getCurrentUrl, objectAssign } from './utils.js';
+import { getPageContextSerializedInHtml } from '../shared/getPageContextSerializedInHtml.js';
+import { getPageFilesAll } from '../../shared/getPageFiles.js';
+import { loadPageFilesClientSide } from '../shared/loadPageFilesClientSide.js';
+export { getPageContext };
+const urlFirst = getCurrentUrl({ withoutHash: true });
+async function getPageContext() {
+    const pageContext = getPageContextSerializedInHtml();
+    objectAssign(pageContext, {
+        isHydration: true,
+        isBackwardNavigation: null,
+        _hasPageContextFromClient: false
+    });
+    objectAssign(pageContext, await loadPageFiles(pageContext._pageId));
+    assertPristineUrl();
+    return pageContext;
+}
+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 loadPageFiles(pageId) {
+    const pageContextAddendum = {};
+    const { pageFilesAll, pageConfigs } = await getPageFilesAll(true);
+    objectAssign(pageContextAddendum, {
+        _pageFilesAll: pageFilesAll,
+        _pageConfigs: pageConfigs
+    });
+    objectAssign(pageContextAddendum, await loadPageFilesClientSide(pageFilesAll, pageConfigs, pageId));
+    pageFilesAll
+        .filter((p) => p.fileType !== '.page.server')
+        .forEach((p) => {
+        assertWarning(!p.fileExports?.onBeforeRender, `export { onBeforeRender } of ${p.filePath} is loaded in the browser but never executed (because you are using Server-side Routing). In order to reduce the size of you browser-side JavaScript, define onBeforeRender() in a .page.server.js file instead, see https://vike.dev/onBeforeRender-isomorphic#server-routing`, { onlyOnce: true });
+    });
+    return pageContextAddendum;
+}

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

@@ -0,0 +1,16 @@
+import type { PageContextBuiltInClientWithServerRouting } from '../../shared/types.js';
+/** @deprecated
+ * Replace:
+ *   ```
+ *   import type { PageContextBuiltInClient } from 'vite-plugin/client'
+ *   ```
+ * With:
+ *   ```
+ *   import type {
+ *     PageContextBuiltInClientWithServerRouting as
+ *     PageContextBuiltInClient
+ *   } from 'vike/types'
+ *   ```
+ */
+type PageContextBuiltInClient<Page = any> = PageContextBuiltInClientWithServerRouting<Page>;
+export type { PageContextBuiltInClient };

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

@@ -0,0 +1,2 @@
+// TODO/v1-release: remove this file
+export {};

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

@@ -0,0 +1,2 @@
+export { onLoad };
+declare function onLoad(): void;

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

@@ -0,0 +1,5 @@
+export { onLoad };
+import { assertIsBrowser } from '../../utils/assertIsBrowser.js';
+function onLoad() {
+    assertIsBrowser();
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,4 @@
+import { setPageFiles } from '../../shared/getPageFiles.js';
+// @ts-ignore
+import * as pageFilesExports from 'virtual:vike:importUserCode:client:server-routing';
+setPageFiles(pageFilesExports);

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

@@ -0,0 +1,14 @@
+export * from '../../utils/assert.js';
+export * from '../../utils/assertSingleInstance.js';
+export * from '../../shared/hooks/executeHook.js';
+export * from '../../utils/checkType.js';
+export * from '../../utils/getCurrentUrl.js';
+export * from '../../utils/getGlobalObject.js';
+export * from '../../utils/hasProp.js';
+export * from '../../utils/isCallable.js';
+export * from '../../utils/isObject.js';
+export * from '../../utils/objectAssign.js';
+export * from '../../utils/parseUrl.js';
+export * from '../../utils/projectInfo.js';
+export * from '../../utils/slice.js';
+export * from '../../utils/unique.js';

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

@@ -0,0 +1,18 @@
+// Utils needed by Server Routing.
+// We assume all runtime entries will load this utils.ts file
+import { onLoad } from './onLoad.js';
+onLoad();
+export * from '../../utils/assert.js';
+export * from '../../utils/assertSingleInstance.js';
+export * from '../../shared/hooks/executeHook.js';
+export * from '../../utils/checkType.js'; // Only used by Server Routing (not needed for Client Routing)
+export * from '../../utils/getCurrentUrl.js';
+export * from '../../utils/getGlobalObject.js';
+export * from '../../utils/hasProp.js';
+export * from '../../utils/isCallable.js';
+export * from '../../utils/isObject.js';
+export * from '../../utils/objectAssign.js';
+export * from '../../utils/parseUrl.js';
+export * from '../../utils/projectInfo.js';
+export * from '../../utils/slice.js';
+export * from '../../utils/unique.js'; // Only used by Server Routing (not needed for Client Routing)

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

@@ -0,0 +1,11 @@
+export { executeOnRenderClientHook };
+import type { PageFile, PageContextExports } from '../../shared/getPageFiles.js';
+import { type PageContextForUserConsumptionClientSide } from './preparePageContextForUserConsumptionClientSide.js';
+import type { PageConfig } from '../../shared/page-configs/PageConfig.js';
+declare function executeOnRenderClientHook<PC extends {
+    _pageFilesLoaded: PageFile[];
+    urlOriginal?: string;
+    urlPathname?: string;
+    _pageId: string;
+    _pageConfigs: PageConfig[];
+} & PageContextExports & PageContextForUserConsumptionClientSide>(pageContext: PC, isClientRouting: boolean): Promise<void>;

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

@@ -0,0 +1,63 @@
+export { executeOnRenderClientHook };
+import { assert, assertUsage, executeHook } from '../server-routing-runtime/utils.js';
+import { getHook } from '../../shared/hooks/getHook.js';
+import { preparePageContextForUserConsumptionClientSide } from './preparePageContextForUserConsumptionClientSide.js';
+async function executeOnRenderClientHook(pageContext, isClientRouting) {
+    const pageContextForUserConsumption = preparePageContextForUserConsumptionClientSide(pageContext, isClientRouting);
+    let hook = null;
+    let hookName;
+    {
+        const renderHook = getHook(pageContext, 'render');
+        hook = renderHook;
+        hookName = 'render';
+    }
+    {
+        const renderHook = getHook(pageContext, 'onRenderClient');
+        if (renderHook) {
+            hook = renderHook;
+            hookName = 'onRenderClient';
+        }
+    }
+    if (!hook) {
+        const urlLogical = getUrlLogical(pageContext);
+        if (pageContext._pageConfigs.length > 0) {
+            // V1 design
+            assertUsage(false, `No onRenderClient() hook defined for URL '${urlLogical}', but it's needed, see https://vike.dev/onRenderClient`);
+        }
+        else {
+            // TODO/v1-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 ' + urlLogical;
+            }
+            else {
+                errMsg =
+                    'One of the following files should export a `render()` hook: ' +
+                        pageClientsFilesLoaded.map((p) => p.filePath).join(' ');
+            }
+            assertUsage(false, errMsg);
+        }
+    }
+    assert(hook);
+    const renderHook = hook.hookFn;
+    assert(hookName);
+    // We don't use a try-catch wrapper because rendering errors are usually handled by the UI framework. (E.g. React's Error Boundaries.)
+    const hookResult = await executeHook(() => renderHook(pageContextForUserConsumption), hookName, hook.hookFilePath);
+    assertUsage(hookResult === undefined, `The ${hookName}() hook defined by ${hook.hookFilePath} isn't allowed to return a value`);
+}
+function getUrlLogical(pageContext) {
+    let url;
+    // try/catch to avoid passToClient assertUsage() (although: this may not be needed anymore, since we're now accessing pageContext and not pageContextForUserConsumption)
+    try {
+        url =
+            // Client Routing
+            pageContext.urlPathname ??
+                // Server Routing
+                pageContext.urlOriginal;
+    }
+    catch { }
+    url = url ?? window.location.href;
+    return url;
+}

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

@@ -0,0 +1,11 @@
+export { getPageContextProxyForUser };
+export { PageContextForPassToClientWarning };
+type PageContextForPassToClientWarning = {
+    _hasPageContextFromServer: boolean;
+    _hasPageContextFromClient: boolean;
+};
+/**
+ * - Throw error when pageContext value isn't serializable
+ * - Throw error when pageContext prop is missing in passToClient
+ */
+declare function getPageContextProxyForUser<PageContext extends Record<string, unknown> & PageContextForPassToClientWarning>(pageContext: PageContext): PageContext;

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

@@ -0,0 +1,66 @@
+export { getPageContextProxyForUser };
+import { assert, assertUsage, getGlobalObject } from '../server-routing-runtime/utils.js';
+import { notSerializable } from '../../shared/notSerializable.js';
+const globalObject = getGlobalObject('getPageContextProxyForUser.ts', {});
+/**
+ * - Throw error when pageContext value isn't serializable
+ * - Throw error when pageContext prop is missing in passToClient
+ */
+function getPageContextProxyForUser(pageContext) {
+    assert([true, false].includes(pageContext._hasPageContextFromServer));
+    assert([true, false].includes(pageContext._hasPageContextFromClient));
+    return new Proxy(pageContext, {
+        get(_, prop) {
+            const val = pageContext[prop];
+            const propName = JSON.stringify(prop);
+            assertUsage(val !== notSerializable, `pageContext[${propName}] couldn't be serialized and, therefore, is missing on the client-side. Check the server logs for more information.`);
+            assertPassToClient(pageContext, prop, `pageContext[${propName}] isn't available on the client-side because ${propName} is missing in passToClient, see https://vike.dev/passToClient`);
+            return val;
+        }
+    });
+}
+function assertPassToClient(pageContext, prop, errMsg) {
+    // We disable assertPassToClient() for the next attempt to read `prop`, because of how Vue's reactivity work. When changing a reactive object:
+    //  - Vue tries to read its old value first. This triggers a `assertPassToClient()` failure if e.g. `pageContextOldReactive.routeParams = pageContextNew.routeParams` and `pageContextOldReactive` has no `routeParams`.
+    //  - Vue seems to read __v_raw before reading the property
+    if (globalObject.prev === prop || globalObject.prev === '__v_raw')
+        return;
+    ignoreNextRead(prop);
+    if (prop in pageContext)
+        return;
+    if (isExpected(prop))
+        return;
+    if (pageContext._hasPageContextFromServer && !pageContext._hasPageContextFromClient) {
+        // We can safely assume that the property is missing in passToClient, because the server-side defines all passToClient properties even if they have an undefined value:
+        // ```
+        // <script id="vike_pageContext" type="application/json">{"_pageId":"/pages/admin","user":"!undefined","pageProps":"!undefined","title":"!undefined","abortReason":"!undefined","_urlRewrite":null}</script>
+        // ```
+        // Note how properties have "!undefined" values => we can tell whether an undefined pageContext value exists in passToClient.
+        assertUsage(false, errMsg);
+    }
+    else {
+        // Do nothing, not even a warning.
+        // Because we don't know whether the user expects the pageContext value to be undefined. (E.g. a client-side onBeforeRender() hook conditionally setting a pageContext value.)
+    }
+}
+const IGNORE_LIST = [
+    'then',
+    'toJSON' // Vue tries to get `toJSON`
+];
+function isExpected(prop) {
+    if (IGNORE_LIST.includes(prop))
+        return true;
+    if (typeof prop === 'symbol')
+        return true; // Vue tries to access some symbols
+    if (typeof prop !== 'string')
+        return true;
+    if (prop.startsWith('__v_'))
+        return true; // Vue internals upon `reactive(pageContext)`
+    return false;
+}
+function ignoreNextRead(prop) {
+    globalObject.prev = prop;
+    window.setTimeout(() => {
+        globalObject.prev = undefined;
+    }, 0);
+}

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

@@ -0,0 +1,5 @@
+export { getPageContextSerializedInHtml };
+declare function getPageContextSerializedInHtml(): {
+    _pageId: string;
+    _hasPageContextFromServer: true;
+};

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

@@ -0,0 +1,16 @@
+import { parse } from '@brillout/json-serializer/parse';
+import { hasProp, assert, assertUsage, objectAssign } from '../server-routing-runtime/utils.js';
+export { getPageContextSerializedInHtml };
+function getPageContextSerializedInHtml() {
+    const id = 'vike_pageContext';
+    const elem = document.getElementById(id);
+    assertUsage(elem, `The element #${id} (which vike automatically injects into the HTML) is missing from the DOM. This may happen if your HTML is malformed. Make sure your HTML isn't malformed, and make sure you don't remove #${id} from the HTML nor from the DOM.`);
+    const pageContextJson = elem.textContent;
+    assert(pageContextJson);
+    const pageContextSerializedInHtml = parse(pageContextJson);
+    assert(hasProp(pageContextSerializedInHtml, '_pageId', 'string'));
+    objectAssign(pageContextSerializedInHtml, {
+        _hasPageContextFromServer: true
+    });
+    return pageContextSerializedInHtml;
+}

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

@@ -0,0 +1,8 @@
+import { type PageFile, type PageContextExports } from '../../shared/getPageFiles.js';
+import type { PageConfig } from '../../shared/page-configs/PageConfig.js';
+export { loadPageFilesClientSide };
+export { isErrorFetchingStaticAssets };
+declare function loadPageFilesClientSide(pageFilesAll: PageFile[], pageConfigs: PageConfig[], pageId: string): Promise<PageContextExports & {
+    _pageFilesLoaded: PageFile[];
+}>;
+declare function isErrorFetchingStaticAssets(err: unknown): boolean;

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

@@ -0,0 +1,64 @@
+import { getPageFilesClientSide, getExports } from '../../shared/getPageFiles.js';
+import { findPageConfig } from '../../shared/page-configs/findPageConfig.js';
+import { loadPageCode } from '../../shared/page-configs/loadPageCode.js';
+export { loadPageFilesClientSide };
+export { isErrorFetchingStaticAssets };
+const stamp = '__whileFetchingAssets';
+async function loadPageFilesClientSide(pageFilesAll, pageConfigs, pageId) {
+    const pageFilesClientSide = getPageFilesClientSide(pageFilesAll, pageId);
+    const pageConfig = findPageConfig(pageConfigs, pageId);
+    let pageConfigLoaded;
+    // @ts-ignore Since dist/cjs/client/ is never used, we can ignore this error.
+    const isDev = import.meta.env.DEV;
+    try {
+        // prettier-ignore
+        const result = await Promise.all([
+            pageConfig && loadPageCode(pageConfig, isDev),
+            ...pageFilesClientSide.map((p) => p.loadFile?.()),
+        ]);
+        pageConfigLoaded = result[0];
+    }
+    catch (err) {
+        // To trigger this catch: add `throw new Error()` in the global scope of +onRenderClient.js
+        if (isFetchError(err)) {
+            Object.assign(err, { [stamp]: true });
+        }
+        throw err;
+    }
+    const { config, configEntries, exports, exportsAll, pageExports } = getExports(pageFilesClientSide, pageConfigLoaded);
+    const pageContextAddendum = {
+        config,
+        configEntries,
+        exports,
+        exportsAll,
+        pageExports,
+        _pageFilesLoaded: pageFilesClientSide
+    };
+    return pageContextAddendum;
+}
+function isErrorFetchingStaticAssets(err) {
+    if (!err) {
+        return false;
+    }
+    return err[stamp] === 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/esm/client/shared/preparePageContextForUserConsumptionClientSide.d.ts

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

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

@@ -0,0 +1,53 @@
+export { preparePageContextForUserConsumptionClientSide };
+import { assert, isObject, objectAssign } from '../server-routing-runtime/utils.js';
+import { sortPageContext } from '../../shared/sortPageContext.js';
+import { addIs404ToPageProps } from '../../shared/addIs404ToPageProps.js';
+import { getPageContextProxyForUser } from './getPageContextProxyForUser.js';
+// Release `pageContext` for user consumption.
+//
+// This adds `assertPassToClient()`.
+//
+// With Vue support (when `pageContext` is made reactive with Vue).
+//
+// For Vue + Cient Routing, the `pageContext` needs to be made reactive:
+// ```js
+// import { reactive } from 'vue'
+// // See entire example at `/examples/vue-full/`
+// const pageContextReactive = reactive(pageContext)
+// ```
+function preparePageContextForUserConsumptionClientSide(pageContext, isClientRouting) {
+    if (isClientRouting) {
+        const pageContextTyped = pageContext;
+        assert([true, false].includes(pageContextTyped.isHydration));
+        assert([true, false, null].includes(pageContextTyped.isBackwardNavigation));
+    }
+    else {
+        const pageContextTyped = pageContext;
+        assert(pageContextTyped.isHydration === true);
+        assert(pageContextTyped.isBackwardNavigation === null);
+    }
+    assert('config' in pageContext);
+    assert('configEntries' in pageContext);
+    // TODO/v1-release: remove
+    assert('exports' in pageContext);
+    assert('exportsAll' in pageContext);
+    assert('pageExports' in pageContext);
+    assert(isObject(pageContext.pageExports));
+    const Page = pageContext.exports.Page;
+    objectAssign(pageContext, { Page });
+    // For Vue's reactivity
+    resolveGetters(pageContext);
+    // For prettier `console.log(pageContext)`
+    sortPageContext(pageContext);
+    const pageContextForUserConsumption = getPageContextProxyForUser(pageContext);
+    addIs404ToPageProps(pageContext);
+    return pageContextForUserConsumption;
+}
+// Remove propery 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/esm/node/cli/bin.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/node/cli/bin.js

@@ -0,0 +1,42 @@
+import { cac } from 'cac';
+import { resolve } from 'path';
+import { prerenderFromCLI, prerenderForceExit } from '../prerender/runPrerender.js';
+import { projectInfo, assertUsage } from './utils.js';
+const cli = cac(projectInfo.projectName);
+cli
+    .command('prerender', 'Pre-render the HTML of your pages', { allowUnknownOptions: true })
+    .option('--configFile <path>', '[string] Path to vite.config.js')
+    .action(async (options) => {
+    assertOptions();
+    const { partial, noExtraDir, base, parallel, outDir, configFile } = options;
+    const root = options.root && resolve(options.root);
+    await prerenderFromCLI({ partial, noExtraDir, base, root, parallel, outDir, configFile });
+    prerenderForceExit();
+});
+function assertOptions() {
+    // Using process.argv because cac convert names to camelCase
+    const rawOptions = process.argv.slice(3);
+    Object.values(rawOptions).forEach((option) => {
+        assertUsage(!option.startsWith('--') ||
+            [
+                '--root',
+                '--partial',
+                '--noExtraDir',
+                '--clientRouter',
+                '--base',
+                '--parallel',
+                '--outDir',
+                '--configFile'
+            ].includes(option), 'Unknown option: ' + option);
+    });
+}
+// Listen to unknown commands
+cli.on('command:*', () => {
+    assertUsage(false, 'Unknown command: ' + cli.args.join(' '));
+});
+cli.help();
+cli.version(projectInfo.projectVersion);
+cli.parse(process.argv.length === 2 ? [...process.argv, '--help'] : process.argv);
+process.on('unhandledRejection', (rejectValue) => {
+    throw rejectValue;
+});

package/dist/esm/node/cli/index.d.ts

@@ -0,0 +1,2 @@
+import { prerender as prerenderOriginal } from '../prerender/index.js';
+export declare const prerender: typeof prerenderOriginal;

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

@@ -0,0 +1,7 @@
+// TODO/v1-release: remove this file
+import { prerender as prerenderOriginal } from '../prerender/index.js';
+import { assertWarning } from './utils.js';
+export const prerender = (options) => {
+    assertWarning(false, "`import { prerender } from 'vike/cli'` is deprecated in favor of `import { prerender } from 'vike/prerender'``", { onlyOnce: true, showStackTrace: true });
+    return prerenderOriginal(options);
+};

package/dist/esm/node/cli/onLoad.d.ts

@@ -0,0 +1,2 @@
+export { onLoad };
+declare function onLoad(): void;

package/dist/esm/node/cli/onLoad.js

@@ -0,0 +1,5 @@
+export { onLoad };
+import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
+function onLoad() {
+    assertIsNotBrowser();
+}

package/dist/esm/node/cli/utils.d.ts

@@ -0,0 +1,2 @@
+export * from '../../utils/assert.js';
+export * from '../../utils/projectInfo.js';

package/dist/esm/node/cli/utils.js

@@ -0,0 +1,5 @@
+// We assume all runtime entries will load this utils.ts file
+import { onLoad } from './onLoad.js';
+onLoad();
+export * from '../../utils/assert.js';
+export * from '../../utils/projectInfo.js';

package/dist/esm/node/client/router.d.ts

@@ -0,0 +1,4 @@
+export { navigate };
+export { reload };
+declare const navigate: never;
+declare const reload: never;