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

package/dist/cjs/node/shared/virtual-files/virtualFilePageConfigValuesAll.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVirtualFileIdPageConfigValuesAll = exports.isVirtualFileIdPageConfigValuesAll = void 0;
+const extractAssetsQuery_js_1 = require("../extractAssetsQuery.js");
+const utils_js_1 = require("../utils.js");
+const idBase = 'virtual:vike:pageConfigValuesAll:';
+const idBaseClient = `${idBase}client:`;
+const idBaseServer = `${idBase}server:`;
+function getVirtualFileIdPageConfigValuesAll(pageId, isForClientSide) {
+    const id = `${(isForClientSide ? idBaseClient : idBaseServer)}${pageId}`;
+    return id;
+}
+exports.getVirtualFileIdPageConfigValuesAll = getVirtualFileIdPageConfigValuesAll;
+function isVirtualFileIdPageConfigValuesAll(id) {
+    id = (0, utils_js_1.getVirtualFileId)(id);
+    if (!id.includes(idBase))
+        return false;
+    (0, utils_js_1.assert)(id.startsWith(idBase));
+    const idOriginal = id;
+    id = (0, extractAssetsQuery_js_1.extractAssetsRemoveQuery)(id);
+    const isExtractAssets = idOriginal !== id;
+    if (id.startsWith(idBaseClient)) {
+        (0, utils_js_1.assert)(isExtractAssets === false);
+        return {
+            pageId: id.slice(idBaseClient.length),
+            isForClientSide: true,
+            isExtractAssets
+        };
+    }
+    if (id.startsWith(idBaseServer)) {
+        return {
+            pageId: id.slice(idBaseServer.length),
+            isForClientSide: false,
+            isExtractAssets
+        };
+    }
+    (0, utils_js_1.assert)(false);
+}
+exports.isVirtualFileIdPageConfigValuesAll = isVirtualFileIdPageConfigValuesAll;

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{ "type": "commonjs" }

package/dist/cjs/shared/ConfigVike.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/shared/RenderErrorPage.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RenderErrorPage = void 0;
+// TODO/v1-release: remove
+var abort_js_1 = require("./route/abort.js");
+Object.defineProperty(exports, "RenderErrorPage", { enumerable: true, get: function () { return abort_js_1.RenderErrorPage; } });

package/dist/cjs/shared/VikeNamespace.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/shared/abort.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.render = exports.redirect = void 0;
+// TODO/v1-release: Move all universal imports (when using Client Routing) to:
+//   import {
+//     redirect,
+//     render,
+//     resolveRoute,
+//     navigate,
+//     prefetch,
+//   } from 'vike'
+// Use package.json#exports to make the imports isomorphic.
+// The client-side has no utility when using Server Routing.
+var abort_js_1 = require("./route/abort.js");
+Object.defineProperty(exports, "redirect", { enumerable: true, get: function () { return abort_js_1.redirect; } });
+Object.defineProperty(exports, "render", { enumerable: true, get: function () { return abort_js_1.render; } });

package/dist/cjs/shared/addIs404ToPageProps.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addIs404ToPageProps = void 0;
+const utils_js_1 = require("./utils.js");
+const error_page_js_1 = require("./error-page.js");
+function addIs404ToPageProps(pageContext) {
+    assertIs404(pageContext);
+    addIs404(pageContext);
+}
+exports.addIs404ToPageProps = addIs404ToPageProps;
+function assertIs404(pageContext) {
+    if ((0, error_page_js_1.isErrorPage)(pageContext._pageId, pageContext._pageConfigs)) {
+        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContext, 'is404', 'boolean'));
+    }
+}
+function addIs404(pageContext) {
+    if (pageContext.is404 === undefined || pageContext.is404 === null)
+        return;
+    const pageProps = pageContext.pageProps || {};
+    if (!(0, utils_js_1.isObject)(pageProps)) {
+        (0, utils_js_1.assertWarning)(false, 'pageContext.pageProps should be an object', { showStackTrace: true, onlyOnce: true });
+        return;
+    }
+    pageProps.is404 = pageProps.is404 || pageContext.is404;
+    pageContext.pageProps = pageProps;
+}

package/dist/cjs/shared/addUrlComputedProps.js

@@ -0,0 +1,111 @@
+"use strict";
+// URLs props need to be computed props, because the user can modify the URL e.g. with onBeforeRoute() for i18n
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertPageContextUrlComputedProps = exports.addUrlComputedProps = void 0;
+const utils_js_1 = require("./utils.js");
+function addUrlComputedProps(pageContext, enumerable = true) {
+    (0, utils_js_1.assert)(pageContext.urlOriginal);
+    if ('urlPathname' in pageContext) {
+        (0, utils_js_1.assert)((0, utils_js_1.hasPropertyGetter)(pageContext, 'urlPathname'));
+    }
+    Object.defineProperty(pageContext, 'urlPathname', {
+        get: urlPathnameGetter,
+        enumerable,
+        configurable: true
+    });
+    // TODO/v1-release: move pageContext.urlParsed to pageContext.url
+    if ('url' in pageContext)
+        (0, utils_js_1.assert)((0, utils_js_1.hasPropertyGetter)(pageContext, 'url'));
+    Object.defineProperty(pageContext, 'url', {
+        get: urlGetter,
+        enumerable: false,
+        configurable: true
+    });
+    if ('urlParsed' in pageContext) {
+        (0, utils_js_1.assert)((0, utils_js_1.hasPropertyGetter)(pageContext, 'urlParsed'));
+    }
+    Object.defineProperty(pageContext, 'urlParsed', {
+        get: urlParsedGetter,
+        enumerable,
+        configurable: true
+    });
+}
+exports.addUrlComputedProps = addUrlComputedProps;
+function getUrlParsed(pageContext) {
+    // We use a url handler function because the onBeforeRoute() hook may modify pageContext.urlOriginal (e.g. for i18n)
+    let urlHandler = pageContext._urlHandler;
+    if (!urlHandler) {
+        urlHandler = (url) => url;
+    }
+    const url = pageContext._urlRewrite ?? pageContext.urlOriginal;
+    (0, utils_js_1.assert)(url && typeof url === 'string');
+    const urlLogical = urlHandler(url);
+    const baseServer = pageContext._baseServer;
+    (0, utils_js_1.assert)(baseServer.startsWith('/'));
+    return (0, utils_js_1.parseUrl)(urlLogical, baseServer);
+}
+function urlPathnameGetter() {
+    const { pathname } = getUrlParsed(this);
+    const urlPathname = pathname;
+    (0, utils_js_1.assert)(urlPathname.startsWith('/'));
+    return urlPathname;
+}
+function urlGetter() {
+    // TODO/v1-release: remove
+    (0, utils_js_1.assertWarning)(false, '`pageContext.url` is outdated. Use `pageContext.urlPathname`, `pageContext.urlParsed`, or `pageContext.urlOriginal` instead. (See https://vike.dev/migration/0.4.23 for more information.)', { onlyOnce: true, showStackTrace: true });
+    return urlPathnameGetter.call(this);
+}
+function urlParsedGetter() {
+    const urlParsedOriginal = getUrlParsed(this);
+    const { origin, pathname, pathnameOriginal, search, searchAll, searchOriginal, hash, hashOriginal } = urlParsedOriginal;
+    const hashIsAvailable = (0, utils_js_1.isBrowser)();
+    const warnHashNotAvailable = (prop) => {
+        (0, utils_js_1.assertWarning)(hashIsAvailable, `pageContext.urlParsed.${prop} isn't available on the server-side (HTTP requests don't include the URL hash by design)`, { onlyOnce: true, showStackTrace: true });
+    };
+    const urlParsed = {
+        origin,
+        pathname,
+        pathnameOriginal,
+        search,
+        searchAll,
+        searchOriginal,
+        get hash() {
+            warnHashNotAvailable('hash');
+            return hash;
+        },
+        get hashOriginal() {
+            warnHashNotAvailable('hashOriginal');
+            return hashOriginal;
+        },
+        get hashString() {
+            (0, utils_js_1.assertWarning)(false, 'pageContext.urlParsed.hashString has been renamed to pageContext.urlParsed.hashOriginal', {
+                onlyOnce: true,
+                showStackTrace: true
+            });
+            warnHashNotAvailable('hashString');
+            return hashOriginal;
+        },
+        get searchString() {
+            (0, utils_js_1.assertWarning)(false, 'pageContext.urlParsed.searchString has been renamed to pageContext.urlParsed.searchOriginal', { onlyOnce: true, showStackTrace: true });
+            return searchOriginal;
+        }
+    };
+    makeNonEnumerable(urlParsed, 'hashString');
+    makeNonEnumerable(urlParsed, 'searchString');
+    if (!hashIsAvailable) {
+        makeNonEnumerable(urlParsed, 'hash');
+        makeNonEnumerable(urlParsed, 'hashOriginal');
+    }
+    return urlParsed;
+}
+function makeNonEnumerable(obj, prop) {
+    const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+    Object.defineProperty(obj, prop, { ...descriptor, enumerable: false });
+}
+function assertPageContextUrlComputedProps(pageContext) {
+    (0, utils_js_1.assert)(typeof pageContext.urlOriginal === 'string');
+    (0, utils_js_1.assert)(typeof pageContext.urlPathname === 'string');
+    (0, utils_js_1.assert)((0, utils_js_1.isPlainObject)(pageContext.urlParsed));
+    (0, utils_js_1.assert)(pageContext.urlPathname === pageContext.urlParsed.pathname);
+}
+exports.assertPageContextUrlComputedProps = assertPageContextUrlComputedProps;

package/dist/cjs/shared/assertHookReturnedObject.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertHookReturnedObject = void 0;
+const utils_js_1 = require("./utils.js");
+function assertHookReturnedObject(obj, keysExpected, errPrefix) {
+    (0, utils_js_1.assert)(!errPrefix.endsWith(' '));
+    const keysUnknown = [];
+    const keys = Object.keys(obj);
+    for (const key of keys) {
+        if (!keysExpected.includes(key)) {
+            keysUnknown.push(key);
+        }
+    }
+    (0, utils_js_1.assertUsage)(keysUnknown.length === 0, [
+        errPrefix,
+        'returned an object with following unknown keys:',
+        (0, utils_js_1.stringifyStringArray)(keysUnknown) + '.',
+        'Only following keys are allowed:',
+        (0, utils_js_1.stringifyStringArray)(keysExpected) + '.'
+    ].join(' '));
+}
+exports.assertHookReturnedObject = assertHookReturnedObject;

package/dist/cjs/shared/assertOnBeforeRenderHookReturn.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertOnBeforeRenderHookReturn = void 0;
+const utils_js_1 = require("./utils.js");
+const assertPageContextProvidedByUser_js_1 = require("./assertPageContextProvidedByUser.js");
+const assertHookReturnedObject_js_1 = require("./assertHookReturnedObject.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+function assertOnBeforeRenderHookReturn(hookReturnValue, hookFilePath) {
+    if (hookReturnValue === undefined || hookReturnValue === null) {
+        return;
+    }
+    const errPrefix = `The onBeforeRender() hook defined by ${hookFilePath}`;
+    (0, utils_js_1.assertUsage)((0, utils_js_1.isPlainObject)(hookReturnValue), `${errPrefix} should return a plain JavaScript object, ${picocolors_1.default.cyan('undefined')}, or ${picocolors_1.default.cyan('null')}`);
+    (0, assertHookReturnedObject_js_1.assertHookReturnedObject)(hookReturnValue, ['pageContext'], errPrefix);
+    if (hookReturnValue.pageContext) {
+        (0, assertPageContextProvidedByUser_js_1.assertPageContextProvidedByUser)(hookReturnValue['pageContext'], { hookName: 'onBeforeRender', hookFilePath });
+    }
+}
+exports.assertOnBeforeRenderHookReturn = assertOnBeforeRenderHookReturn;

package/dist/cjs/shared/assertPageContextProvidedByUser.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertPageContextProvidedByUser = void 0;
+const utils_js_1 = require("./utils.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+function assertPageContextProvidedByUser(pageContextProvidedByUser, { hookName, hookFilePath }) {
+    if (pageContextProvidedByUser === undefined || pageContextProvidedByUser === null)
+        return;
+    (0, utils_js_1.assert)(!hookName.endsWith(')'));
+    const errPrefix = `The ${picocolors_1.default.cyan('pageContext')} object provided by the ${hookName}() hook defined by ${hookFilePath}`;
+    (0, utils_js_1.assertUsage)((0, utils_js_1.isObject)(pageContextProvidedByUser), `${errPrefix} should be an object (but it's ${picocolors_1.default.cyan(`typeof pageContext === ${JSON.stringify(typeof pageContextProvidedByUser)}`)} instead)`);
+    (0, utils_js_1.assertUsage)(!('_objectCreatedByVike' in pageContextProvidedByUser), `${errPrefix} shouldn't be the whole ${picocolors_1.default.cyan('pageContext')} object, see https://vike.dev/pageContext-manipulation#do-not-return-entire-pagecontext`);
+    // In principle, it's possible to use onBeforeRoute()` to override and define the whole routing.
+    // Is that a good idea to allow users to do this? Beyond deep integration with Vue Router or React Router, is there a use case for this?
+    (0, utils_js_1.assertWarning)(!('_pageId' in pageContextProvidedByUser), `${errPrefix} sets ${picocolors_1.default.cyan('pageContext._pageId')} which means that vike's routing is overriden. This is an experimental feature: make sure to contact a vike maintainer before using this.`, { onlyOnce: true });
+    (0, utils_js_1.assertUsage)(!('is404' in pageContextProvidedByUser), `${errPrefix} sets ${picocolors_1.default.cyan('pageContext.is404')} which is forbidden, use ${picocolors_1.default.cyan('throw render()')} instead, see https://vike.dev/render`);
+}
+exports.assertPageContextProvidedByUser = assertPageContextProvidedByUser;

package/dist/cjs/shared/assertPageFilePath.js

@@ -0,0 +1,12 @@
+"use strict";
+// TODO/v1-release: remove
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertPageFilePath = void 0;
+const utils_js_1 = require("./utils.js");
+function assertPageFilePath(filePath) {
+    (0, utils_js_1.assertPosixPath)(filePath);
+    /* This assert() is skipped to reduce client-side bundle size
+    assert(filePath.startsWith('/') || isNpmPackageImport(filePath), { filePath })
+    */
+}
+exports.assertPageFilePath = assertPageFilePath;

package/dist/cjs/shared/determinePageIdOld.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determinePageIdOld = void 0;
+const utils_js_1 = require("./utils.js");
+// TODO/v1-release: remove
+function determinePageIdOld(filePath) {
+    const pageSuffix = '.page.';
+    const pageId = (0, utils_js_1.slice)(filePath.split(pageSuffix), 0, -1).join(pageSuffix);
+    (0, utils_js_1.assert)(!pageId.includes('\\'));
+    return pageId;
+}
+exports.determinePageIdOld = determinePageIdOld;

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

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

package/dist/cjs/shared/getPageContextRequestUrl.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doNotCreateExtraDirectory = exports.pageContextJsonFileExtension = exports.getPageContextRequestUrl = void 0;
+// This module isn't loaded by the client-side of Server Routing => we don't inlcude `urlToFile` to `./utils.ts`
+const urlToFile_js_1 = require("../utils/urlToFile.js");
+const pageContextJsonFileExtension = '.pageContext.json';
+exports.pageContextJsonFileExtension = pageContextJsonFileExtension;
+// `/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;
+exports.doNotCreateExtraDirectory = doNotCreateExtraDirectory;
+// See node/renderPage/handlePageContextRequestUrl.ts
+function getPageContextRequestUrl(url) {
+    const pageContextRequestUrl = (0, urlToFile_js_1.urlToFile)(url, pageContextJsonFileExtension, doNotCreateExtraDirectory);
+    return pageContextRequestUrl;
+}
+exports.getPageContextRequestUrl = getPageContextRequestUrl;

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeClientSide = void 0;
+const utils_js_1 = require("../page-configs/utils.js");
+const analyzePageClientSide_js_1 = require("./analyzePageClientSide.js");
+function analyzeClientSide(pageConfig, pageFilesAll, pageId) {
+    // V1 design
+    if (pageConfig) {
+        const isClientRouting = (0, utils_js_1.getConfigValue)(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
+        const isClientSideRenderable = (0, utils_js_1.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 } = (0, analyzePageClientSide_js_1.analyzePageClientSide)(pageFilesAll, pageId);
+        return { isClientSideRenderable: !isHtmlOnly, isClientRouting };
+    }
+}
+exports.analyzeClientSide = analyzeClientSide;

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeExports = void 0;
+const getExportNames_js_1 = require("./getExportNames.js");
+const utils_js_1 = require("../../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' && (0, getExportNames_js_1.getExportNames)(p).includes('render'));
+            if (definesClientRenderer) {
+                return false;
+            }
+        }
+        return true;
+    }
+    function assertClientSideRenderHook() {
+        const hasClientSideRenderHook = pageFilesClientSide.some((p) => {
+            return (0, getExportNames_js_1.getExportNames)(p).includes('render');
+        });
+        (0, utils_js_1.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 (0, getExportNames_js_1.getExportNames)(p).includes('clientRouting');
+        });
+        return hasClientRoutingExport;
+    }
+}
+exports.analyzeExports = analyzeExports;

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVikeClientEntry = exports.determineClientEntry = void 0;
+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 };
+}
+exports.determineClientEntry = determineClientEntry;
+function getVikeClientEntry(isClientRouting) {
+    return isClientRouting
+        ? '@@vike/dist/esm/client/client-routing-runtime/entry.js'
+        : '@@vike/dist/esm/client/server-routing-runtime/entry.js';
+}
+exports.getVikeClientEntry = getVikeClientEntry;

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExportNames = void 0;
+const utils_js_1 = require("../../utils.js");
+function getExportNames(p) {
+    if (p.fileType === '.css') {
+        return [];
+    }
+    if (p.exportNames) {
+        return p.exportNames;
+    }
+    (0, utils_js_1.assert)(p.fileExports, p.filePath);
+    const exportNames = Object.keys(p.fileExports);
+    return exportNames;
+}
+exports.getExportNames = getExportNames;

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzePageClientSideInit = exports.analyzePageClientSide = void 0;
+const analyzeExports_js_1 = require("./analyzePageClientSide/analyzeExports.js");
+const determineClientEntry_js_1 = require("./analyzePageClientSide/determineClientEntry.js");
+const getAllPageIdFiles_js_1 = require("./getAllPageIdFiles.js");
+const getAllPageIdFiles_js_2 = require("./getAllPageIdFiles.js");
+const utils_js_1 = require("../utils.js");
+const getExportNames_js_1 = require("./analyzePageClientSide/getExportNames.js");
+// TODO/v1-release: remove analyzePageClientSide(), use analyzeClientSide() instead
+function analyzePageClientSide(pageFilesAll, pageId) {
+    let pageFilesClientSide = (0, getAllPageIdFiles_js_1.getPageFilesClientSide)(pageFilesAll, pageId);
+    const pageFilesServerSide = (0, getAllPageIdFiles_js_2.getPageFilesServerSide)(pageFilesAll, pageId);
+    const { isHtmlOnly, isClientRouting } = (0, analyzeExports_js_1.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') && !(0, getExportNames_js_1.getExportNames)(p).includes('render'));
+        pageFilesClientSide = removeOverridenPageFiles(pageFilesClientSide);
+    }
+    const { clientEntries, clientDependencies } = (0, determineClientEntry_js_1.determineClientEntry)({
+        pageFilesClientSide,
+        pageFilesServerSide,
+        isHtmlOnly,
+        isClientRouting
+    });
+    return { isHtmlOnly, isClientRouting, clientEntries, clientDependencies, pageFilesClientSide, pageFilesServerSide };
+}
+exports.analyzePageClientSide = analyzePageClientSide;
+// TODO:v1-release: remove
+async function analyzePageClientSideInit(pageFilesAll, pageId, { sharedPageFilesAlreadyLoaded }) {
+    const pageFilesClientSide = (0, getAllPageIdFiles_js_1.getPageFilesClientSide)(pageFilesAll, pageId);
+    await Promise.all(pageFilesClientSide.map(async (p) => {
+        (0, utils_js_1.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)
+        }
+        */
+    }));
+}
+exports.analyzePageClientSideInit = analyzePageClientSideInit;
+// [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 ((0, getExportNames_js_1.getExportNames)(p).includes('overrideDefaultPages')) {
+            break;
+        }
+    }
+    return pageFilesClientSide_;
+}

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzePageServerSide = void 0;
+const utils_js_1 = require("../utils.js");
+const getAllPageIdFiles_js_1 = require("./getAllPageIdFiles.js");
+async function analyzePageServerSide(pageFilesAll, pageId) {
+    const pageFilesServerSide = (0, getAllPageIdFiles_js_1.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;
+        }
+        (0, utils_js_1.assert)(p.loadExportNames, pageId);
+        await p.loadExportNames();
+    }));
+    const hasOnBeforeRenderServerSideOnlyHook = pageFilesServerSideOnly.some(({ exportNames }) => {
+        (0, utils_js_1.assert)(exportNames);
+        return exportNames.includes('onBeforeRender');
+    });
+    return { hasOnBeforeRenderServerSideOnlyHook };
+}
+exports.analyzePageServerSide = analyzePageServerSide;

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

@@ -0,0 +1,24 @@
+"use strict";
+// TODO/v1-release: remove this
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forbiddenDefaultExports = exports.assertExportValues = exports.assertDefaultExports = void 0;
+const utils_js_1 = require("../utils.js");
+const enforceTrue = ['clientRouting'];
+function assertExportValues(pageFile) {
+    enforceTrue.forEach((exportName) => {
+        (0, utils_js_1.assert)(pageFile.fileExports);
+        if (!(exportName in pageFile.fileExports))
+            return;
+        const explainer = `The value of \`${exportName}\` is only allowed to be \`true\`.`;
+        (0, utils_js_1.assertUsage)(pageFile.fileExports[exportName] !== false, `${pageFile.filePath} has \`export { ${exportName} }\` with the value \`false\` which is prohibited: remove \`export { ${exportName} }\` instead. (${explainer})`);
+        (0, utils_js_1.assertUsage)(pageFile.fileExports[exportName] === true, `${pageFile.filePath} has \`export { ${exportName} }\` with a forbidden value. ${explainer}`);
+    });
+}
+exports.assertExportValues = assertExportValues;
+// 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'];
+exports.forbiddenDefaultExports = forbiddenDefaultExports;
+function assertDefaultExports(defaultExportName, filePath) {
+    (0, utils_js_1.assertUsage)(!forbiddenDefaultExports.includes(defaultExportName), `${filePath} has \`export default { ${defaultExportName} }\` which is prohibited, use \`export { ${defaultExportName} }\` instead.`);
+}
+exports.assertDefaultExports = assertDefaultExports;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertPageConfigGlobal = exports.assertPageConfigs = void 0;
+const utils_js_1 = require("../utils.js");
+function assertPageConfigs(pageConfigs) {
+    (0, utils_js_1.assert)(Array.isArray(pageConfigs));
+    pageConfigs.forEach((pageConfig) => {
+        (0, utils_js_1.assert)((0, utils_js_1.isObject)(pageConfig));
+        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageConfig, 'pageId', 'string'));
+        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageConfig, 'routeFilesystem'));
+    });
+}
+exports.assertPageConfigs = assertPageConfigs;
+function assertPageConfigGlobal(pageConfigGlobal) {
+    (0, utils_js_1.assert)(pageConfigGlobal);
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageConfigGlobal, 'onBeforeRoute'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageConfigGlobal, 'onPrerenderStart'));
+}
+exports.assertPageConfigGlobal = assertPageConfigGlobal;