vike 0.0.0-alpha.0 → 0.4.142-commit-8bf568b

package/dist/esm/shared/error-page.js

@@ -0,0 +1,38 @@
+export { getErrorPageId };
+export { isErrorPageId };
+export { isErrorPage };
+// TODO/v1-release: consider loading this file only for Client Routing
+import { assert, assertUsage, unique } from './utils.js';
+function getErrorPageId(pageFilesAll, pageConfigs) {
+    if (pageConfigs.length > 0) {
+        const errorPageConfigs = pageConfigs.filter((p) => p.isErrorPage);
+        if (errorPageConfigs.length === 0)
+            return null;
+        assertUsage(errorPageConfigs.length === 1, 'Only one error page can be defined');
+        return errorPageConfigs[0].pageId;
+    }
+    // TODO/v1-release: remove
+    const errorPageIds = unique(pageFilesAll.map(({ pageId }) => pageId).filter((pageId) => isErrorPageId(pageId, false)));
+    assertUsage(errorPageIds.length <= 1, `Only one _error.page.js is allowed, but found several: ${errorPageIds.join(' ')}`);
+    if (errorPageIds.length > 0) {
+        const errorPageId = errorPageIds[0];
+        assert(errorPageId);
+        return errorPageId;
+    }
+    return null;
+}
+// TODO/v1-release: remove
+function isErrorPageId(pageId, _isV1Design) {
+    assert(!pageId.includes('\\'));
+    return pageId.includes('/_error');
+}
+function isErrorPage(pageId, pageConfigs) {
+    if (pageConfigs.length > 0) {
+        const pageConfig = pageConfigs.find((p) => p.pageId === pageId);
+        assert(pageConfig);
+        return pageConfig.isErrorPage;
+    }
+    else {
+        return isErrorPageId(pageId, false);
+    }
+}

package/dist/esm/shared/getPageContextRequestUrl.d.ts

@@ -0,0 +1,6 @@
+export { getPageContextRequestUrl };
+export { pageContextJsonFileExtension };
+export { doNotCreateExtraDirectory };
+declare const pageContextJsonFileExtension = ".pageContext.json";
+declare const doNotCreateExtraDirectory = false;
+declare function getPageContextRequestUrl(url: string): string;

package/dist/esm/shared/getPageContextRequestUrl.js

@@ -0,0 +1,13 @@
+export { getPageContextRequestUrl };
+export { pageContextJsonFileExtension };
+export { doNotCreateExtraDirectory };
+// This module isn't loaded by the client-side of Server Routing => we don't inlcude `urlToFile` to `./utils.ts`
+import { urlToFile } from '../utils/urlToFile.js';
+const pageContextJsonFileExtension = '.pageContext.json';
+// `/some-base-url/index.pageContext.json` instead of `/some-base-url.pageContext.json` in order to comply to common reverse proxy setups, see https://github.com/vikejs/vike/issues/443
+const doNotCreateExtraDirectory = false;
+// See node/renderPage/handlePageContextRequestUrl.ts
+function getPageContextRequestUrl(url) {
+    const pageContextRequestUrl = urlToFile(url, pageContextJsonFileExtension, doNotCreateExtraDirectory);
+    return pageContextRequestUrl;
+}

package/dist/esm/shared/getPageFiles/analyzeClientSide.d.ts

@@ -0,0 +1,7 @@
+export { analyzeClientSide };
+import type { PageConfig } from '../page-configs/PageConfig.js';
+import type { PageFile } from './getPageFileObject.js';
+declare function analyzeClientSide(pageConfig: PageConfig | null, pageFilesAll: PageFile[], pageId: string): {
+    isClientSideRenderable: boolean;
+    isClientRouting: boolean;
+};

package/dist/esm/shared/getPageFiles/analyzeClientSide.js

@@ -0,0 +1,19 @@
+export { analyzeClientSide };
+import { getConfigValue } from '../page-configs/utils.js';
+import { analyzePageClientSide } from './analyzePageClientSide.js';
+function analyzeClientSide(pageConfig, pageFilesAll, pageId) {
+    // V1 design
+    if (pageConfig) {
+        const isClientRouting = getConfigValue(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
+        const isClientSideRenderable = getConfigValue(pageConfig, 'isClientSideRenderable', 'boolean')?.value ?? false;
+        return { isClientSideRenderable, isClientRouting };
+    }
+    else {
+        // TODO/v1-release:
+        //  - remove V0.4 implementation
+        //  - globally rename isHtmlOnly to !isClientSideRenderable
+        // V0.4 design
+        const { isHtmlOnly, isClientRouting } = analyzePageClientSide(pageFilesAll, pageId);
+        return { isClientSideRenderable: !isHtmlOnly, isClientRouting };
+    }
+}

package/dist/esm/shared/getPageFiles/analyzePageClientSide/ClientDependency.d.ts

@@ -0,0 +1,6 @@
+export type { ClientDependency };
+type ClientDependency = {
+    id: string;
+    onlyAssets: boolean;
+    eagerlyImported: boolean;
+};

package/dist/esm/shared/getPageFiles/analyzePageClientSide/ClientDependency.js

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

package/dist/esm/shared/getPageFiles/analyzePageClientSide/analyzeExports.d.ts

@@ -0,0 +1,10 @@
+export { analyzeExports };
+import type { PageFile } from '../getPageFileObject.js';
+declare function analyzeExports({ pageFilesClientSide, pageFilesServerSide, pageId }: {
+    pageFilesClientSide: PageFile[];
+    pageFilesServerSide: PageFile[];
+    pageId: string;
+}): {
+    isHtmlOnly: boolean;
+    isClientRouting: boolean;
+};

package/dist/esm/shared/getPageFiles/analyzePageClientSide/analyzeExports.js

@@ -0,0 +1,48 @@
+export { analyzeExports };
+import { getExportNames } from './getExportNames.js';
+import { assertUsage } from '../../utils.js';
+// TODO/v1-release: remove
+function analyzeExports({ pageFilesClientSide, pageFilesServerSide, pageId }) {
+    return { isHtmlOnly: isHtmlOnly(), isClientRouting: isClientRouting() };
+    function isHtmlOnly() {
+        {
+            const hasPageIdIsmrphFile = pageFilesServerSide.some((p) => p.pageId === pageId && p.fileType === '.page');
+            if (hasPageIdIsmrphFile) {
+                assertClientSideRenderHook();
+                return false;
+            }
+        }
+        {
+            const hasPageIdServerFile = pageFilesServerSide.some((p) => p.pageId === pageId && p.fileType === '.page.server');
+            if (!hasPageIdServerFile) {
+                return false;
+            }
+        }
+        {
+            const definesClientRenderer = pageFilesClientSide.some((p) => p.pageId === pageId && p.fileType === '.page.client' && getExportNames(p).includes('render'));
+            if (definesClientRenderer) {
+                return false;
+            }
+        }
+        return true;
+    }
+    function assertClientSideRenderHook() {
+        const hasClientSideRenderHook = pageFilesClientSide.some((p) => {
+            return getExportNames(p).includes('render');
+        });
+        assertUsage(hasClientSideRenderHook, [
+            'No client-side `render()` hook found.',
+            'See https://vike.dev/render-modes for more information.',
+            [
+                'Loaded client-side page files (none of them `export { render }`):',
+                ...pageFilesClientSide.map((p, i) => ` (${i + 1}): ${p.filePath}`)
+            ].join('\n')
+        ].join(' '));
+    }
+    function isClientRouting() {
+        const hasClientRoutingExport = pageFilesClientSide.some((p) => {
+            return getExportNames(p).includes('clientRouting');
+        });
+        return hasClientRoutingExport;
+    }
+}

package/dist/esm/shared/getPageFiles/analyzePageClientSide/determineClientEntry.d.ts

@@ -0,0 +1,14 @@
+export { determineClientEntry };
+export { getVikeClientEntry };
+import type { ClientDependency } from './ClientDependency.js';
+import type { PageFile } from '../../../shared/getPageFiles.js';
+declare function determineClientEntry({ pageFilesClientSide, pageFilesServerSide, isHtmlOnly, isClientRouting }: {
+    pageFilesClientSide: PageFile[];
+    pageFilesServerSide: PageFile[];
+    isHtmlOnly: boolean;
+    isClientRouting: boolean;
+}): {
+    clientEntries: string[];
+    clientDependencies: ClientDependency[];
+};
+declare function getVikeClientEntry(isClientRouting: boolean): "@@vike/dist/esm/client/client-routing-runtime/entry.js" | "@@vike/dist/esm/client/server-routing-runtime/entry.js";

package/dist/esm/shared/getPageFiles/analyzePageClientSide/determineClientEntry.js

@@ -0,0 +1,27 @@
+export { determineClientEntry };
+export { getVikeClientEntry };
+function determineClientEntry({ pageFilesClientSide, pageFilesServerSide, isHtmlOnly, isClientRouting }) {
+    let clientEntries = [];
+    const pageFilesServerSideOnly = pageFilesServerSide.filter((p) => !pageFilesClientSide.includes(p));
+    const clientDependencies = [];
+    clientDependencies.push(...pageFilesClientSide.map((p) => ({ id: p.filePath, onlyAssets: false, eagerlyImported: false })));
+    // CSS & assets
+    clientDependencies.push(...pageFilesServerSideOnly.map((p) => ({ id: p.filePath, onlyAssets: true, eagerlyImported: false })));
+    // Handle SPA & SSR pages.
+    if (isHtmlOnly) {
+        clientEntries = pageFilesClientSide.map((p) => p.filePath);
+    }
+    else {
+        // Add the vike client entry
+        const clientEntry = getVikeClientEntry(isClientRouting);
+        clientDependencies.push({ id: clientEntry, onlyAssets: false, eagerlyImported: false });
+        clientEntries = [clientEntry];
+    }
+    // console.log(pageFilesClientSide, pageFilesServerSide, clientDependencies, clientEntry)
+    return { clientEntries, clientDependencies };
+}
+function getVikeClientEntry(isClientRouting) {
+    return isClientRouting
+        ? '@@vike/dist/esm/client/client-routing-runtime/entry.js'
+        : '@@vike/dist/esm/client/server-routing-runtime/entry.js';
+}

package/dist/esm/shared/getPageFiles/analyzePageClientSide/getExportNames.d.ts

@@ -0,0 +1,3 @@
+export { getExportNames };
+import type { PageFile } from '../getPageFileObject.js';
+declare function getExportNames(p: PageFile): string[];

package/dist/esm/shared/getPageFiles/analyzePageClientSide/getExportNames.js

@@ -0,0 +1,13 @@
+export { getExportNames };
+import { assert } from '../../utils.js';
+function getExportNames(p) {
+    if (p.fileType === '.css') {
+        return [];
+    }
+    if (p.exportNames) {
+        return p.exportNames;
+    }
+    assert(p.fileExports, p.filePath);
+    const exportNames = Object.keys(p.fileExports);
+    return exportNames;
+}

package/dist/esm/shared/getPageFiles/analyzePageClientSide.d.ts

@@ -0,0 +1,17 @@
+export { analyzePageClientSide };
+export { analyzePageClientSideInit };
+export type { AnalysisResult };
+import type { PageFile } from './getPageFileObject.js';
+import type { ClientDependency } from './analyzePageClientSide/ClientDependency.js';
+type AnalysisResult = {
+    isHtmlOnly: boolean;
+    isClientRouting: boolean;
+    clientEntries: string[];
+    clientDependencies: ClientDependency[];
+    pageFilesClientSide: PageFile[];
+    pageFilesServerSide: PageFile[];
+};
+declare function analyzePageClientSide(pageFilesAll: PageFile[], pageId: string): AnalysisResult;
+declare function analyzePageClientSideInit(pageFilesAll: PageFile[], pageId: string, { sharedPageFilesAlreadyLoaded }: {
+    sharedPageFilesAlreadyLoaded: boolean;
+}): Promise<void>;

package/dist/esm/shared/getPageFiles/analyzePageClientSide.js

@@ -0,0 +1,58 @@
+export { analyzePageClientSide };
+export { analyzePageClientSideInit };
+import { analyzeExports } from './analyzePageClientSide/analyzeExports.js';
+import { determineClientEntry } from './analyzePageClientSide/determineClientEntry.js';
+import { getPageFilesClientSide } from './getAllPageIdFiles.js';
+import { getPageFilesServerSide } from './getAllPageIdFiles.js';
+import { assert } from '../utils.js';
+import { getExportNames } from './analyzePageClientSide/getExportNames.js';
+// TODO/v1-release: remove analyzePageClientSide(), use analyzeClientSide() instead
+function analyzePageClientSide(pageFilesAll, pageId) {
+    let pageFilesClientSide = getPageFilesClientSide(pageFilesAll, pageId);
+    const pageFilesServerSide = getPageFilesServerSide(pageFilesAll, pageId);
+    const { isHtmlOnly, isClientRouting } = analyzeExports({ pageFilesClientSide, pageFilesServerSide, pageId });
+    if (isHtmlOnly) {
+        // HTML-only pages don't need any client-side `render()` hook. For apps that have both HTML-only and SSR/SPA pages, we skip the `.page.client.js` file that defines `render()` for HTML-only pages.
+        pageFilesClientSide = pageFilesClientSide.filter((p) => p.isEnv('CLIENT_ONLY') && !getExportNames(p).includes('render'));
+        pageFilesClientSide = removeOverridenPageFiles(pageFilesClientSide);
+    }
+    const { clientEntries, clientDependencies } = determineClientEntry({
+        pageFilesClientSide,
+        pageFilesServerSide,
+        isHtmlOnly,
+        isClientRouting
+    });
+    return { isHtmlOnly, isClientRouting, clientEntries, clientDependencies, pageFilesClientSide, pageFilesServerSide };
+}
+// TODO:v1-release: remove
+async function analyzePageClientSideInit(pageFilesAll, pageId, { sharedPageFilesAlreadyLoaded }) {
+    const pageFilesClientSide = getPageFilesClientSide(pageFilesAll, pageId);
+    await Promise.all(pageFilesClientSide.map(async (p) => {
+        assert(p.isEnv('CLIENT_ONLY') || p.isEnv('CLIENT_AND_SERVER'));
+        if (sharedPageFilesAlreadyLoaded && p.isEnv('CLIENT_AND_SERVER')) {
+            return;
+        }
+        // TODO: Is `loadExportNames()` cached ? Does it use filesExports if possible? HMR?
+        await p.loadExportNames?.();
+        /*
+        if (pageFile.exportNames) {
+          return pageFile.exportNames.includes(clientRouting)
+        }
+        if (pageFile.fileExports) {
+          return Object.keys(pageFile.fileExports).includes(clientRouting)
+        }
+        */
+    }));
+}
+// [WIP] Just an experiment needed by https://vike.dev/banner
+//  - Not sure I want to make something like a public API: the CSS of `_default.page.server.js` are still loaded -> weird DX.
+function removeOverridenPageFiles(pageFilesClientSide) {
+    const pageFilesClientSide_ = [];
+    for (const p of pageFilesClientSide) {
+        pageFilesClientSide_.push(p);
+        if (getExportNames(p).includes('overrideDefaultPages')) {
+            break;
+        }
+    }
+    return pageFilesClientSide_;
+}

package/dist/esm/shared/getPageFiles/analyzePageServerSide.d.ts

@@ -0,0 +1,5 @@
+export { analyzePageServerSide };
+import type { PageFile } from './getPageFileObject.js';
+declare function analyzePageServerSide(pageFilesAll: PageFile[], pageId: string): Promise<{
+    hasOnBeforeRenderServerSideOnlyHook: boolean;
+}>;

package/dist/esm/shared/getPageFiles/analyzePageServerSide.js

@@ -0,0 +1,20 @@
+export { analyzePageServerSide };
+import { assert } from '../utils.js';
+import { getPageFilesServerSide } from './getAllPageIdFiles.js';
+async function analyzePageServerSide(pageFilesAll, pageId) {
+    const pageFilesServerSide = getPageFilesServerSide(pageFilesAll, pageId);
+    const pageFilesServerSideOnly = pageFilesServerSide.filter((p) => p.fileType === '.page.server');
+    await Promise.all(pageFilesServerSideOnly.map(async (p) => {
+        // In production, `exportNames` are preload
+        if (p.exportNames) {
+            return;
+        }
+        assert(p.loadExportNames, pageId);
+        await p.loadExportNames();
+    }));
+    const hasOnBeforeRenderServerSideOnlyHook = pageFilesServerSideOnly.some(({ exportNames }) => {
+        assert(exportNames);
+        return exportNames.includes('onBeforeRender');
+    });
+    return { hasOnBeforeRenderServerSideOnlyHook };
+}

package/dist/esm/shared/getPageFiles/assertExports.d.ts

@@ -0,0 +1,7 @@
+export { assertDefaultExports };
+export { assertExportValues };
+export { forbiddenDefaultExports };
+import type { PageFile } from './getPageFileObject.js';
+declare function assertExportValues(pageFile: PageFile): void;
+declare const forbiddenDefaultExports: string[];
+declare function assertDefaultExports(defaultExportName: string, filePath: string): void;

package/dist/esm/shared/getPageFiles/assertExports.js

@@ -0,0 +1,21 @@
+// TODO/v1-release: remove this
+export { assertDefaultExports };
+export { assertExportValues };
+export { forbiddenDefaultExports };
+import { assert, assertUsage } from '../utils.js';
+const enforceTrue = ['clientRouting'];
+function assertExportValues(pageFile) {
+    enforceTrue.forEach((exportName) => {
+        assert(pageFile.fileExports);
+        if (!(exportName in pageFile.fileExports))
+            return;
+        const explainer = `The value of \`${exportName}\` is only allowed to be \`true\`.`;
+        assertUsage(pageFile.fileExports[exportName] !== false, `${pageFile.filePath} has \`export { ${exportName} }\` with the value \`false\` which is prohibited: remove \`export { ${exportName} }\` instead. (${explainer})`);
+        assertUsage(pageFile.fileExports[exportName] === true, `${pageFile.filePath} has \`export { ${exportName} }\` with a forbidden value. ${explainer}`);
+    });
+}
+// Forbid exports such as `export default { render }`, because only `export { render }` can be statically analyzed by `es-module-lexer`.
+const forbiddenDefaultExports = ['render', 'clientRouting', 'prerender', 'doNotPrerender'];
+function assertDefaultExports(defaultExportName, filePath) {
+    assertUsage(!forbiddenDefaultExports.includes(defaultExportName), `${filePath} has \`export default { ${defaultExportName} }\` which is prohibited, use \`export { ${defaultExportName} }\` instead.`);
+}

package/dist/esm/shared/getPageFiles/assertPageConfigs.d.ts

@@ -0,0 +1,5 @@
+export { assertPageConfigs };
+export { assertPageConfigGlobal };
+import type { PageConfig, PageConfigGlobal } from '../page-configs/PageConfig.js';
+declare function assertPageConfigs(pageConfigs: unknown): asserts pageConfigs is PageConfig[];
+declare function assertPageConfigGlobal(pageConfigGlobal: unknown): asserts pageConfigGlobal is PageConfigGlobal;

package/dist/esm/shared/getPageFiles/assertPageConfigs.js

@@ -0,0 +1,16 @@
+export { assertPageConfigs };
+export { assertPageConfigGlobal };
+import { assert, isObject, hasProp } from '../utils.js';
+function assertPageConfigs(pageConfigs) {
+    assert(Array.isArray(pageConfigs));
+    pageConfigs.forEach((pageConfig) => {
+        assert(isObject(pageConfig));
+        assert(hasProp(pageConfig, 'pageId', 'string'));
+        assert(hasProp(pageConfig, 'routeFilesystem'));
+    });
+}
+function assertPageConfigGlobal(pageConfigGlobal) {
+    assert(pageConfigGlobal);
+    assert(hasProp(pageConfigGlobal, 'onBeforeRoute'));
+    assert(hasProp(pageConfigGlobal, 'onPrerenderStart'));
+}

package/dist/esm/shared/getPageFiles/fileTypes.d.ts

@@ -0,0 +1,8 @@
+export type { FileType };
+export { fileTypes };
+export { isValidFileType };
+export { determineFileType };
+declare const fileTypes: readonly [".page", ".page.server", ".page.route", ".page.client", ".css"];
+type FileType = (typeof fileTypes)[number];
+declare function isValidFileType(filePath: string): boolean;
+declare function determineFileType(filePath: string): FileType;

package/dist/esm/shared/getPageFiles/fileTypes.js

@@ -0,0 +1,50 @@
+// TODO/v1-release: remove
+export { fileTypes };
+export { isValidFileType };
+export { determineFileType };
+import { assert, assertPosixPath } from '../utils.js';
+import { isScriptFile } from '../../utils/isScriptFile.js';
+const fileTypes = [
+    '.page',
+    '.page.server',
+    '.page.route',
+    '.page.client',
+    // New type `.page.css`/`.page.server.css`/`.page.client.css` for `extensions[number].pageFileDist`.
+    //  - Extensions using `pageFileDist` are expected to use a bundler that generates a `.css` colocated next to the original `.page.js` file (e.g. `/renderer/_default.page.server.css` for `/renderer/_default.page.server.js`.
+    //  - Since these `.page.css` files Bundlers We can therefore expect that there isn't any `.page.server.sass`/...
+    '.css'
+];
+function isValidFileType(filePath) {
+    return ['.js', '.mjs', '.cjs', '.css'].some((ext) => filePath.endsWith(ext));
+}
+function determineFileType(filePath) {
+    assertPosixPath(filePath);
+    {
+        const isCSS = filePath.endsWith('.css');
+        if (isCSS) {
+            /* This assert() is skipped to reduce client-side bundle size
+            assert(isNpmPackageImport(filePath), filePath) // `.css` page files are only supported for npm packages
+            */
+            return '.css';
+        }
+    }
+    assert(isScriptFile(filePath), filePath);
+    const fileName = filePath.split('/').slice(-1)[0];
+    const parts = fileName.split('.');
+    const suffix1 = parts.slice(-3)[0];
+    const suffix2 = parts.slice(-2)[0];
+    if (suffix2 === 'page') {
+        return '.page';
+    }
+    assert(suffix1 === 'page', filePath);
+    if (suffix2 === 'server') {
+        return '.page.server';
+    }
+    if (suffix2 === 'client') {
+        return '.page.client';
+    }
+    if (suffix2 === 'route') {
+        return '.page.route';
+    }
+    assert(false, filePath);
+}

package/dist/esm/shared/getPageFiles/getAllPageIdFiles.d.ts

@@ -0,0 +1,5 @@
+export { getPageFilesClientSide };
+export { getPageFilesServerSide };
+import type { PageFile } from './getPageFileObject.js';
+declare function getPageFilesClientSide(pageFilesAll: PageFile[], pageId: string): PageFile[];
+declare function getPageFilesServerSide(pageFilesAll: PageFile[], pageId: string): PageFile[];

package/dist/esm/shared/getPageFiles/getAllPageIdFiles.js

@@ -0,0 +1,103 @@
+// TODO:v1-release: remove this file
+export { getPageFilesClientSide };
+export { getPageFilesServerSide };
+import { assert, assertUsage, isNotNullish } from '../utils.js';
+import { assertPageFilePath } from '../assertPageFilePath.js';
+function getPageFilesClientSide(pageFilesAll, pageId) {
+    return determine(pageFilesAll, pageId, true);
+}
+function getPageFilesServerSide(pageFilesAll, pageId) {
+    return determine(pageFilesAll, pageId, false);
+}
+function determine(pageFilesAll, pageId, envIsClient) {
+    const env = envIsClient ? 'CLIENT_ONLY' : 'SERVER_ONLY';
+    const pageFilesRelevant = pageFilesAll
+        .filter((p) => p.isRelevant(pageId) && p.fileType !== '.page.route')
+        .sort(getPageFilesSorter(envIsClient, pageId));
+    // Load the `.page.js` files specific to `pageId`
+    const getPageIdFile = (iso) => {
+        const files = pageFilesRelevant.filter((p) => p.pageId === pageId && p.isEnv(iso ? 'CLIENT_AND_SERVER' : env));
+        assertUsage(files.length <= 1, `Merge the following files into a single file: ${files.map((p) => p.filePath).join(' ')}`);
+        const pageIdFile = files[0];
+        assert(pageIdFile === undefined || !pageIdFile.isDefaultPageFile);
+        return pageIdFile;
+    };
+    const pageIdFileEnv = getPageIdFile(false);
+    const pageIdFileIso = getPageIdFile(true);
+    // A page can have only one renderer. In other words: Multiple `renderer/` overwrite each other.
+    // Load only load renderer (`/renderer/_default.*`)
+    const getRendererFile = (iso) => pageFilesRelevant.filter((p) => p.isRendererPageFile && p.isEnv(iso ? 'CLIENT_AND_SERVER' : env))[0];
+    const rendererFileEnv = getRendererFile(false);
+    const rendererFileIso = getRendererFile(true);
+    // A page can load multiple `_defaut.page.*` files of the same `fileType`. In other words: non-renderer `_default.page.*` files are cumulative.
+    // The exception being HTML-only pages because we pick a single page file as client entry. We handle that use case at `renderPage()`.
+    const defaultFilesNonRenderer = pageFilesRelevant.filter((p) => p.isDefaultPageFile && !p.isRendererPageFile && (p.isEnv(env) || p.isEnv('CLIENT_AND_SERVER')));
+    // Ordered by `pageContext.exports` precendence
+    const pageFiles = [pageIdFileEnv, pageIdFileIso, ...defaultFilesNonRenderer, rendererFileEnv, rendererFileIso].filter(isNotNullish);
+    return pageFiles;
+}
+function getPageFilesSorter(envIsClient, pageId) {
+    const env = envIsClient ? 'CLIENT_ONLY' : 'SERVER_ONLY';
+    const e1First = -1;
+    const e2First = +1;
+    const noOrder = 0;
+    return (e1, e2) => {
+        // `.page.js` files specific to `pageId` first
+        if (!e1.isDefaultPageFile && e2.isDefaultPageFile) {
+            return e1First;
+        }
+        if (!e2.isDefaultPageFile && e1.isDefaultPageFile) {
+            return e2First;
+        }
+        // Non-renderer `_default.page.*` before `renderer/**/_default.page.*`
+        {
+            const e1_isRenderer = e1.isRendererPageFile;
+            const e2_isRenderer = e2.isRendererPageFile;
+            if (!e1_isRenderer && e2_isRenderer) {
+                return e1First;
+            }
+            if (!e2_isRenderer && e1_isRenderer) {
+                return e2First;
+            }
+            assert(e1_isRenderer === e2_isRenderer);
+        }
+        // Filesystem nearest first
+        {
+            const e1_distance = getPathDistance(pageId, e1.filePath);
+            const e2_distance = getPathDistance(pageId, e2.filePath);
+            if (e1_distance < e2_distance) {
+                return e1First;
+            }
+            if (e2_distance < e1_distance) {
+                return e2First;
+            }
+            assert(e1_distance === e2_distance);
+        }
+        // `.page.server.js`/`.page.client.js` before `.page.js`
+        {
+            if (e1.isEnv(env) && e2.isEnv('CLIENT_AND_SERVER')) {
+                return e1First;
+            }
+            if (e2.isEnv(env) && e1.isEnv('CLIENT_AND_SERVER')) {
+                return e2First;
+            }
+        }
+        return noOrder;
+    };
+}
+function getPathDistance(pathA, pathB) {
+    assertPageFilePath(pathA);
+    assertPageFilePath(pathB);
+    // Index of first different character
+    let idx = 0;
+    for (; idx < pathA.length && idx < pathB.length; idx++) {
+        if (pathA[idx] !== pathB[idx])
+            break;
+    }
+    const pathAWithoutCommon = pathA.slice(idx);
+    const pathBWithoutCommon = pathB.slice(idx);
+    const distanceA = pathAWithoutCommon.split('/').length;
+    const distanceB = pathBWithoutCommon.split('/').length;
+    const distance = distanceA + distanceB;
+    return distance;
+}

package/dist/esm/shared/getPageFiles/getExports.d.ts

@@ -0,0 +1,39 @@
+export { getExportUnion };
+export { getExports };
+export type { ExportsAll };
+export type { PageContextExports };
+export type { ConfigEntries };
+import type { FileType } from './fileTypes.js';
+import type { PageConfigLoaded } from './../page-configs/PageConfig.js';
+import type { PageFile } from './getPageFileObject.js';
+type ExportsAll = Record<string, {
+    exportValue: unknown;
+    exportSource: string;
+    /** @deprecated */
+    _fileType: FileType | null;
+    /** @deprecated */
+    _isFromDefaultExport: boolean | null;
+    /** @deprecated */
+    filePath: string | null;
+    /** @deprecated */
+    _filePath: string | null;
+}[]>;
+/** All the config's values (including overriden ones) and where they come from.
+ *
+ * https://vike.dev/pageContext
+ */
+type ConfigEntries = Record<string, {
+    configValue: unknown;
+    configDefinedAt: string;
+    configDefinedByFile: string | null;
+}[]>;
+type PageContextExports = {
+    config: Record<string, unknown>;
+    configEntries: ConfigEntries;
+    exports: Record<string, unknown>;
+    exportsAll: ExportsAll;
+    /** @deprecated */
+    pageExports: Record<string, unknown>;
+};
+declare function getExports(pageFiles: PageFile[], pageConfig: PageConfigLoaded | null): PageContextExports;
+declare function getExportUnion(exportsAll: ExportsAll, propName: string): string[];